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


#include <Python.h>

#if PY_VERSION_HEX >= 0x030d0000
inline PyObject *PyWeakref_GetObject_emu(PyObject *ref)
{
  PyObject *ret = NULL;
  if(PyWeakref_GetRef(ref, &ret) > 0)
    Py_DECREF(ret);
  return ret;
}
#undef PyWeakref_GET_OBJECT
#define PyWeakref_GET_OBJECT(x) PyWeakref_GetObject_emu(x)
#endif



#undef slots

#ifndef SWIG_GENERATED
#define SWIG_GENERATED
#endif

// we want visual assist to ignore this file, because it's a *lot* of generated code and has no
// useful results. This macro does nothing on normal builds, but is defined to _asm { in va_stdafx.h
#define VA_IGNORE_REST_OF_FILE
VA_IGNORE_REST_OF_FILE



#ifndef SWIGPYTHON
#define SWIGPYTHON
#endif

#define SWIG_PYTHON_NO_BUILD_NONE
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIGPYTHON_BUILTIN


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
# undef _DEBUG
# include <Python.h>
# define _DEBUG
#else
# include <Python.h>
#endif

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

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

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

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.

  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

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

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

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


/*
   Flags/methods for returning states.

   The SWIG conversion methods, as ConvertPtr, return an integer
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).

   Use the following macros/flags to set or process the returning
   states.

   In old versions of SWIG, code such as the following was usually written:

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

   Now you can be more explicit:

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

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

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
	delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }

   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

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

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

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

       int food(double)
       int fooi(int);

   and you call

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

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

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

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

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


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

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

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

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

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

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

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

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

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

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

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

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

/*
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
	SWIG_TypeClientData(tc, clientdata);
      }
    }
    cast = cast->next;
  }
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
                            swig_module_info *end,
		            const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      size_t l = 0;
      size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	size_t i = (l + r) >> 1;
	const char *iname = iter->types[i]->name;
	if (iname) {
	  int compare = strcmp(name, iname);
	  if (compare == 0) {
	    return iter->types[i];
	  } else if (compare < 0) {
	    if (i) {
	      r = i - 1;
	    } else {
	      break;
	    }
	  } else if (compare > 0) {
	    l = i + 1;
	  }
	} else {
	  break; /* should never happen */
	}
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).

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

  /* neither found a match */
  return 0;
}

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

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

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

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

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

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

#ifdef __cplusplus
}
#endif

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



/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000

#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)	
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)

#endif

#ifndef Py_TYPE
#  define Py_TYPE(op) ((op)->ob_type)
#endif

/* SWIG APIs for compatibility of both Python 2 & 3 */

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
#  define SWIG_Python_str_FromFormat PyString_FromFormat
#endif


/* Warning: This function will allocate a new string in Python 3,
 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
 */
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03000000
  char *cstr;
  char *newstr;
  Py_ssize_t len;
  str = PyUnicode_AsUTF8String(str);
  PyBytes_AsStringAndSize(str, &cstr, &len);
  newstr = (char *) malloc(len+1);
  memcpy(newstr, cstr, len+1);
  Py_XDECREF(str);
  return newstr;
#else
  return PyString_AsString(str);
#endif
}

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
#else
#  define SWIG_Python_str_DelForPy3(x) 
#endif


SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_FromString(c); 
#else
  return PyString_FromString(c);
#endif
}

/* Add PyOS_snprintf for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
#  define PyOS_snprintf _snprintf
# else
#  define PyOS_snprintf snprintf
# endif
#endif

/* A crude PyString_FromFormat implementation for old Pythons */
#if PY_VERSION_HEX < 0x02020000

#ifndef SWIG_PYBUFFER_SIZE
# define SWIG_PYBUFFER_SIZE 1024
#endif

static PyObject *
PyString_FromFormat(const char *fmt, ...) {
  va_list ap;
  char buf[SWIG_PYBUFFER_SIZE * 2];
  int res;
  va_start(ap, fmt);
  res = vsnprintf(buf, sizeof(buf), fmt, ap);
  va_end(ap);
  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
}
#endif

#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

/* A crude PyExc_StopIteration exception for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# ifndef PyExc_StopIteration
#  define PyExc_StopIteration PyExc_RuntimeError
# endif
# ifndef PyObject_GenericGetAttr
#  define PyObject_GenericGetAttr 0
# endif
#endif

/* Py_NotImplemented is defined in 2.1 and up. */
#if PY_VERSION_HEX < 0x02010000
# ifndef Py_NotImplemented
#  define Py_NotImplemented PyExc_RuntimeError
# endif
#endif

/* A crude PyString_AsStringAndSize implementation for old Pythons */
#if PY_VERSION_HEX < 0x02010000
# ifndef PyString_AsStringAndSize
#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
# endif
#endif

/* PySequence_Size for old Pythons */
#if PY_VERSION_HEX < 0x02000000
# ifndef PySequence_Size
#  define PySequence_Size PySequence_Length
# endif
#endif

/* PyBool_FromLong for old Pythons */
#if PY_VERSION_HEX < 0x02030000
static
PyObject *PyBool_FromLong(long ok)
{
  PyObject *result = ok ? Py_True : Py_False;
  Py_INCREF(result);
  return result;
}
#endif

/* Py_ssize_t for old Pythons */
/* This code is as recommended by: */
/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
typedef int Py_ssize_t;
# define PY_SSIZE_T_MAX INT_MAX
# define PY_SSIZE_T_MIN INT_MIN
typedef inquiry lenfunc;
typedef intargfunc ssizeargfunc;
typedef intintargfunc ssizessizeargfunc;
typedef intobjargproc ssizeobjargproc;
typedef intintobjargproc ssizessizeobjargproc;
typedef getreadbufferproc readbufferproc;
typedef getwritebufferproc writebufferproc;
typedef getsegcountproc segcountproc;
typedef getcharbufferproc charbufferproc;
static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
{
  long result = 0;
  PyObject *i = PyNumber_Int(x);
  if (i) {
    result = PyInt_AsLong(i);
    Py_DECREF(i);
  }
  return result;
}
#endif

#if PY_VERSION_HEX < 0x02050000
#define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
#endif

#if PY_VERSION_HEX < 0x02040000
#define Py_VISIT(op)				\
  do { 						\
    if (op) {					\
      int vret = visit((op), arg);		\
      if (vret)					\
        return vret;				\
    }						\
  } while (0)
#endif

#if PY_VERSION_HEX < 0x02030000
typedef struct {
  PyTypeObject type;
  PyNumberMethods as_number;
  PyMappingMethods as_mapping;
  PySequenceMethods as_sequence;
  PyBufferProcs as_buffer;
  PyObject *name, *slots;
} PyHeapTypeObject;
#endif

#if PY_VERSION_HEX < 0x02030000
typedef destructor freefunc;
#endif

#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
     (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
     (PY_MAJOR_VERSION > 3))
# define SWIGPY_USE_CAPSULE
# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
#endif

#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif

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

SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
  PyObject* type = 0;
  switch(code) {
  case SWIG_MemoryError:
    type = PyExc_MemoryError;
    break;
  case SWIG_IOError:
    type = PyExc_IOError;
    break;
  case SWIG_RuntimeError:
    type = PyExc_RuntimeError;
    break;
  case SWIG_IndexError:
    type = PyExc_IndexError;
    break;
  case SWIG_TypeError:
    type = PyExc_TypeError;
    break;
  case SWIG_DivisionByZero:
    type = PyExc_ZeroDivisionError;
    break;
  case SWIG_OverflowError:
    type = PyExc_OverflowError;
    break;
  case SWIG_SyntaxError:
    type = PyExc_SyntaxError;
    break;
  case SWIG_ValueError:
    type = PyExc_ValueError;
    break;
  case SWIG_SystemError:
    type = PyExc_SystemError;
    break;
  case SWIG_AttributeError:
    type = PyExc_AttributeError;
    break;
  default:
    type = PyExc_RuntimeError;
  }
  return type;
}


SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
  PyObject *type = 0;
  PyObject *value = 0;
  PyObject *traceback = 0;

  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
  if (value) {
    char *tmp;
    PyObject *old_str = PyObject_Str(value);
    PyErr_Clear();
    Py_XINCREF(type);

    PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(old_str);
    Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

#if defined(SWIG_PYTHON_NO_THREADS)
#  if defined(SWIG_PYTHON_THREADS)
#    undef SWIG_PYTHON_THREADS
#  endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
#    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
#      define SWIG_PYTHON_USE_GIL
#    endif
#  endif
#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
#    ifndef SWIG_PYTHON_INITIALIZE_THREADS
#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
#    endif
#    ifdef __cplusplus /* C++ code */
       class SWIG_Python_Thread_Block {
         bool status;
         PyGILState_STATE state;
       public:
         void end() { if (status) { PyGILState_Release(state); status = false;} }
         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
         ~SWIG_Python_Thread_Block() { end(); }
       };
       class SWIG_Python_Thread_Allow {
         bool status;
         PyThreadState *save;
       public:
         void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
         ~SWIG_Python_Thread_Allow() { end(); }
       };
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
#    else /* C code */
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
#    endif
#  else /* Old thread way, not implemented, user must provide it */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      define SWIG_PYTHON_INITIALIZE_THREADS
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
#      define SWIG_PYTHON_THREAD_END_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
#      define SWIG_PYTHON_THREAD_END_ALLOW
#    endif
#  endif
#else /* No thread support */
#  define SWIG_PYTHON_INITIALIZE_THREADS
#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#  define SWIG_PYTHON_THREAD_END_BLOCK
#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#  define SWIG_PYTHON_THREAD_END_ALLOW
#endif

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

#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * Constant declarations
 * ----------------------------------------------------------------------------- */

/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY  5

/* Constant information structure */
typedef struct swig_const_info {
  int type;
  char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;


/* -----------------------------------------------------------------------------
 * Wrapper of PyInstanceMethod_New() used in Python 3
 * It is exported to the generated module, used for -fastproxy
 * ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX >= 0x03000000
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
{
  return PyInstanceMethod_New(func);
}
#else
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
{
  return NULL;
}
#endif

#ifdef __cplusplus
}
#endif


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

/* Common SWIG API */

/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)

#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif

#define SWIG_InternalNewPointerObj(ptr, type, flags)	SWIG_Python_NewPointerObj(NULL, ptr, type, flags)

#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype                                    int

/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)

/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)

/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)

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


/* Runtime API */

#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)

#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
#define SWIG_fail                        		goto fail					   


/* Runtime API implementation */

/* Error manipulation */

SWIGINTERN void 
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
  PyErr_SetObject(errtype, obj);
  Py_DECREF(obj);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

SWIGINTERN void 
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  PyErr_SetString(errtype, msg);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
  PyObject *s = PyString_InternFromString(key);
  PyList_Append(seq, s);
  Py_DECREF(s);
}

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
#if PY_VERSION_HEX < 0x02030000
  PyDict_SetItemString(d, (char *)name, obj);
#else
  PyDict_SetItemString(d, name, obj);
#endif
  Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
#if PY_VERSION_HEX < 0x02030000
  PyDict_SetItemString(d, (char *)name, obj);
#else
  PyDict_SetItemString(d, name, obj);
#endif
  Py_DECREF(obj);                            
}

#endif

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      PyList_SetItem(result, 0, o2);
    }
    PyList_Append(result,obj);
    Py_DECREF(obj);
  }
  return result;
#else
  PyObject*   o2;
  PyObject*   o3;
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyTuple_Check(result)) {
      o2 = result;
      result = PyTuple_New(1);
      PyTuple_SET_ITEM(result, 0, o2);
    }
    o3 = PyTuple_New(1);
    PyTuple_SET_ITEM(o3, 0, obj);
    o2 = result;
    result = PySequence_Concat(o2, o3);
    Py_DECREF(o2);
    Py_DECREF(o3);
  }
  return result;
#endif
}

/* Unpack the argument tuple */

SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
  if (!args) {
    if (!min && !max) {
      return 1;
    } else {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
		   name, (min == max ? "" : "at least "), (int)min);
      return 0;
    }
  }  
  if (!PyTuple_Check(args)) {
    if (min <= 1 && max >= 1) {
      Py_ssize_t i;
      objs[0] = args;
      for (i = 1; i < max; ++i) {
	objs[i] = 0;
      }
      return 2;
    }
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    return 0;
  } else {
    Py_ssize_t l = PyTuple_GET_SIZE(args);
    if (l < min) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at least "), (int)min, (int)l);
      return 0;
    } else if (l > max) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at most "), (int)max, (int)l);
      return 0;
    } else {
      Py_ssize_t i;
      for (i = 0; i < l; ++i) {
	objs[i] = PyTuple_GET_ITEM(args, i);
      }
      for (; l < max; ++l) {
	objs[l] = 0;
      }
      return i + 1;
    }    
  }
}

/* A functor is a function object with one single object argument */
#if PY_VERSION_HEX >= 0x02020000
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);
#else
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunction(functor, "O", obj);
#endif

/*
  Helper for static pointer initialization for both C and C++ code, for example
  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var)  var
#else
#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
#endif

/* -----------------------------------------------------------------------------
 * Pointer declarations
 * ----------------------------------------------------------------------------- */

/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

#define SWIG_BUILTIN_TP_INIT	    (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT	    (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)

#ifdef __cplusplus
extern "C" {
#endif

/*  How to access Py_None */
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#  ifndef SWIG_PYTHON_NO_BUILD_NONE
#    ifndef SWIG_PYTHON_BUILD_NONE
#      define SWIG_PYTHON_BUILD_NONE
#    endif
#  endif
#endif

#ifdef SWIG_PYTHON_BUILD_NONE
#  ifdef Py_None
#   undef Py_None
#   define Py_None SWIG_Py_None()
#  endif
SWIGRUNTIMEINLINE PyObject * 
_SWIG_Py_None(void)
{
  PyObject *none = Py_BuildValue((char*)"");
  Py_DECREF(none);
  return none;
}
SWIGRUNTIME PyObject * 
SWIG_Py_None(void)
{
  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
  return none;
}
#endif

/* The python void return value */

SWIGRUNTIMEINLINE PyObject * 
SWIG_Py_Void(void)
{
  PyObject *none = Py_None;
  Py_INCREF(none);
  return none;
}

/* SwigPyClientData */

typedef struct {
  PyObject *klass;
  PyObject *newraw;
  PyObject *newargs;
  PyObject *destroy;
  int delargs;
  int implicitconv;
  PyTypeObject *pytype;
} SwigPyClientData;

SWIGRUNTIMEINLINE int 
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
  return data ? data->implicitconv : 0;
}

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
  PyObject *klass = data ? data->klass : 0;
  return (klass ? klass : PyExc_RuntimeError);
}


SWIGRUNTIME SwigPyClientData * 
SwigPyClientData_New(PyObject* obj)
{
  if (!obj) {
    return 0;
  } else {
    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    /* the klass element */
    data->klass = obj;
    Py_INCREF(data->klass);
    /* the newraw method and newargs arguments used to create a new raw instance */
    if (PyClass_Check(obj)) {
      data->newraw = 0;
      data->newargs = obj;
      Py_INCREF(obj);
    } else {
#if (PY_VERSION_HEX < 0x02020000)
      data->newraw = 0;
#else
      data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
#endif
      if (data->newraw) {
	Py_INCREF(data->newraw);
	data->newargs = PyTuple_New(1);
	PyTuple_SetItem(data->newargs, 0, obj);
      } else {
	data->newargs = obj;
      }
      Py_INCREF(data->newargs);
    }
    /* the destroy method, aka as the C++ delete method */
    data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
    if (PyErr_Occurred()) {
      PyErr_Clear();
      data->destroy = 0;
    }
    if (data->destroy) {
      int flags;
      Py_INCREF(data->destroy);
      flags = PyCFunction_GET_FLAGS(data->destroy);
#ifdef METH_O
      data->delargs = !(flags & (METH_O));
#else
      data->delargs = 0;
#endif
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

SWIGRUNTIME void 
SwigPyClientData_Del(SwigPyClientData *data) {
  Py_XDECREF(data->newraw);
  Py_XDECREF(data->newargs);
  Py_XDECREF(data->destroy);
}

/* =============== SwigPyObject =====================*/

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *parent;
  PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
  PyObject *dict;
#endif
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;

  if (!sobj->dict)
    sobj->dict = PyDict_New();

  Py_INCREF(sobj->dict);
  return sobj->dict;
}

#endif

SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
  return PyLong_FromVoidPtr(v->ptr);
}

SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
  PyObject *res = NULL;
  PyObject *args = PyTuple_New(1);
  if (args) {
    if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
      PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
      if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
	res = PyUnicode_Format(ofmt,args);
#else
	res = PyString_Format(ofmt,args);
#endif
	Py_DECREF(ofmt);
      }
      Py_DECREF(args);
    }
  }
  return res;
}

SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
  return SwigPyObject_format("%o",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
  return SwigPyObject_format("%x",v);
}

SWIGRUNTIME PyObject *
#ifdef METH_NOARGS
SwigPyObject_repr(SwigPyObject *v)
#else
SwigPyObject_repr(SwigPyObject *v, PyObject *args)
#endif
{
  const char *name = SWIG_TypePrettyName(v->ty);
  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
  if (v->next) {
# ifdef METH_NOARGS
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
# else
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
# endif
# if PY_VERSION_HEX >= 0x03000000
    PyObject *joined = PyUnicode_Concat(repr, nrep);
    Py_DecRef(repr);
    Py_DecRef(nrep);
    repr = joined;
# else
    PyString_ConcatAndDel(&repr,nrep);
# endif
  }
  return repr;  
}

SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
  void *i = v->ptr;
  void *j = w->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
  PyObject* res;
  if( PyErr_Occurred() ) {
    return NULL;
  }
  if( op != Py_EQ && op != Py_NE ) {
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
  }
  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
  return res;  
}


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
    SwigPyClientData *cd;
    assert(SwigPyObject_stype);
    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    assert(cd);
    assert(cd->pytype);
    return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
  return type;
}
#endif

SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
  if (op == NULL) return 0;
#ifdef SWIGPYTHON_BUILTIN
  PyTypeObject *target_tp = SwigPyObject_type();
  if (PyType_IsSubtype(op->ob_type, target_tp))
    return 1;
  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
  return (Py_TYPE(op) == SwigPyObject_type())
    || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);

SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  PyObject *next = sobj->next;
  if (sobj->own == SWIG_POINTER_OWN) {
    swig_type_info *ty = sobj->ty;
    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    PyObject *destroy = data ? data->destroy : 0;
    if (destroy) {
      /* destroy is always a VARARGS method */
      PyObject *res;

      /* PyObject_CallFunction() has the potential to silently drop
         the active active exception.  In cases of unnamed temporary
         variable or where we just finished iterating over a generator
         StopIteration will be active right now, and this needs to
         remain true upon return from SwigPyObject_dealloc.  So save
         and restore. */
      
      PyObject *val = NULL, *type = NULL, *tb = NULL;
      PyErr_Fetch(&val, &type, &tb);

      if (data->delargs) {
        /* we need to create a temporary object to carry the destroy operation */
        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
        res = SWIG_Python_CallFunctor(destroy, tmp);
        Py_DECREF(tmp);
      } else {
        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
        PyObject *mself = PyCFunction_GET_SELF(destroy);
        res = ((*meth)(mself, v));
      }
      if (!res)
        PyErr_WriteUnraisable(destroy);

      PyErr_Restore(val, type, tb);

      Py_XDECREF(res);
    } 
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    else {
      const char *name = SWIG_TypePrettyName(ty);
      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    }
#endif
  } 
  Py_XDECREF(next);
  PyObject_DEL(v);
}

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
#ifndef METH_O
  PyObject *tmp = 0;
  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
  next = tmp;
#endif
  if (!SwigPyObject_Check(next)) {
    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    return NULL;
  }
  sobj->next = next;
  Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
#ifdef METH_NOARGS
SwigPyObject_next(PyObject* v)
#else
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    Py_INCREF(sobj->next);
    return sobj->next;
  } else {
    return SWIG_Py_Void();
  }
}

SWIGINTERN PyObject*
#ifdef METH_NOARGS
SwigPyObject_disown(PyObject *v)
#else
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = 0;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
#ifdef METH_NOARGS
SwigPyObject_acquire(PyObject *v)
#else
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = SWIG_POINTER_OWN;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
  PyObject *val = 0;
#if (PY_VERSION_HEX < 0x02020000)
  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
#elif (PY_VERSION_HEX < 0x02050000)
  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
#else
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 
#endif
    {
      return NULL;
    } 
  else
    {
      SwigPyObject *sobj = (SwigPyObject *)v;
      PyObject *obj = PyBool_FromLong(sobj->own);
      if (val) {
#ifdef METH_NOARGS
	if (PyObject_IsTrue(val)) {
	  SwigPyObject_acquire(v);
	} else {
	  SwigPyObject_disown(v);
	}
#else
	if (PyObject_IsTrue(val)) {
	  SwigPyObject_acquire(v,args);
	} else {
	  SwigPyObject_disown(v,args);
	}
#endif
      } 
      return obj;
    }
}

#ifdef METH_O
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#else
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"acquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#endif

#if PY_VERSION_HEX < 0x02020000
SWIGINTERN PyObject *
SwigPyObject_getattr(SwigPyObject *sobj,char *name)
{
  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
}
#endif

SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";

  static PyNumberMethods SwigPyObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    /* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc)0, /*nb_divide*/
#endif
    (binaryfunc)0, /*nb_remainder*/
    (binaryfunc)0, /*nb_divmod*/
    (ternaryfunc)0,/*nb_power*/
    (unaryfunc)0,  /*nb_negative*/
    (unaryfunc)0,  /*nb_positive*/
    (unaryfunc)0,  /*nb_absolute*/
    (inquiry)0,    /*nb_nonzero*/
    0,		   /*nb_invert*/
    0,		   /*nb_lshift*/
    0,		   /*nb_rshift*/
    0,		   /*nb_and*/
    0,		   /*nb_xor*/
    0,		   /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
    0,   /*nb_coerce*/
#endif
    (unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_long, /*nb_long*/
#else
    0, /*nb_reserved*/
#endif
    (unaryfunc)0,                 /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      (char *)"SwigPyObject",               /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
      0,                                    /* tp_print */
#if PY_VERSION_HEX < 0x02020000
      (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
#else
      (getattrfunc)0,                       /* tp_getattr */
#endif
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyObject_repr,          /* tp_repr */
      &SwigPyObject_as_number,              /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      0,                                    /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigobject_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      swigobject_methods,                   /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
      0,                                    /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
      0,                                    /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
      0,                                    /* tp_prev */
#endif
      0                                     /* tp_next */
#endif
    };
    swigpyobject_type = tmp;
    type_init = 1;
#if PY_VERSION_HEX < 0x02020000
    swigpyobject_type.ob_type = &PyType_Type;
#else
    if (PyType_Ready(&swigpyobject_type) < 0)
      return NULL;
#endif
  }
  return &swigpyobject_type;
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
  if (sobj) {
    sobj->ptr  = ptr;
    sobj->ty   = ty;
    sobj->own  = own;
    sobj->next = 0;
  }
  return (PyObject *)sobj;
}

/* -----------------------------------------------------------------------------
 * Implements a simple Swig Packed type, and use it instead of string
 * ----------------------------------------------------------------------------- */

typedef struct {
  PyObject_HEAD
  void *pack;
  swig_type_info *ty;
  size_t size;
} SwigPyPacked;

SWIGRUNTIME int
SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
  char result[SWIG_BUFFER_SIZE];
  fputs("<Swig Packed ", fp); 
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    fputs("at ", fp); 
    fputs(result, fp); 
  }
  fputs(v->ty->name,fp); 
  fputs(">", fp);
  return 0; 
}
  
SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
  }  
}

SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromChar(v->ty->name);
  }  
}

SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
  size_t i = v->size;
  size_t j = w->size;
  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
}

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
  return type;
}

SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
  return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
    || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}

SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
  if (SwigPyPacked_Check(v)) {
    SwigPyPacked *sobj = (SwigPyPacked *) v;
    free(sobj->pack);
  }
  PyObject_DEL(v);
}

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      (char *)"SwigPyPacked",               /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
      (printfunc)SwigPyPacked_print,        /* tp_print */
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
      0, /* tp_reserved in 3.0.1 */
#else
      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
      0,                                    /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      (reprfunc)SwigPyPacked_str,           /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigpacked_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      0,                                    /* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      0,                                    /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
      0,                                    /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
      0,                                    /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
      0,                                    /* tp_prev */
#endif
      0                                     /* tp_next */
#endif
    };
    swigpypacked_type = tmp;
    type_init = 1;
#if PY_VERSION_HEX < 0x02020000
    swigpypacked_type.ob_type = &PyType_Type;
#else
    if (PyType_Ready(&swigpypacked_type) < 0)
      return NULL;
#endif
  }
  return &swigpypacked_type;
}

SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
  if (sobj) {
    void *pack = malloc(size);
    if (pack) {
      memcpy(pack, ptr, size);
      sobj->pack = pack;
      sobj->ty   = ty;
      sobj->size = size;
    } else {
      PyObject_DEL((PyObject *) sobj);
      sobj = 0;
    }
  }
  return (PyObject *) sobj;
}

SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
  if (SwigPyPacked_Check(obj)) {
    SwigPyPacked *sobj = (SwigPyPacked *)obj;
    if (sobj->size != size) return 0;
    memcpy(ptr, sobj->pack, size);
    return sobj->ty;
  } else {
    return 0;
  }
}

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

SWIGRUNTIMEINLINE PyObject *
_SWIG_This(void)
{
    return SWIG_Python_str_FromChar("this");
}

static PyObject *swig_this = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (swig_this == NULL)
    swig_this = _SWIG_This();
  return swig_this;
}

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS 
#endif

SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

  if (SwigPyObject_Check(pyobj))
    return (SwigPyObject *) pyobj;

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
# ifdef PyWeakref_CheckProxy
  if (PyWeakref_CheckProxy(pyobj)) {
    pyobj = PyWeakref_GET_OBJECT(pyobj);
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
# endif
  return NULL;
#else

  obj = 0;

#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
  if (PyInstance_Check(pyobj)) {
    obj = _PyInstance_Lookup(pyobj, SWIG_This());      
  } else {
    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    if (dictptr != NULL) {
      PyObject *dict = *dictptr;
      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    } else {
#ifdef PyWeakref_CheckProxy
      if (PyWeakref_CheckProxy(pyobj)) {
	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
      }
#endif
      obj = PyObject_GetAttr(pyobj,SWIG_This());
      if (obj) {
	Py_DECREF(obj);
      } else {
	if (PyErr_Occurred()) PyErr_Clear();
	return 0;
      }
    }
  }
#else
  obj = PyObject_GetAttr(pyobj,SWIG_This());
  if (obj) {
    Py_DECREF(obj);
  } else {
    if (PyErr_Occurred()) PyErr_Clear();
    return 0;
  }
#endif
  if (obj && !SwigPyObject_Check(obj)) {
    /* a PyObject is called 'this', try to get the 'real this'
       SwigPyObject from it */ 
    return SWIG_Python_GetSwigThis(obj);
  }
  return (SwigPyObject *)obj;
#endif
}

/* Acquire a pointer value */

SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
  if (own == SWIG_POINTER_OWN) {
    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    if (sobj) {
      int oldown = sobj->own;
      sobj->own = own;
      return oldown;
    }
  }
  return 0;
}

/* Convert a pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
  int res;
  SwigPyObject *sobj;
  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;

  if (!obj)
    return SWIG_ERROR;
  if (obj == Py_None && !implicit_conv) {
    if (ptr)
      *ptr = 0;
    return SWIG_OK;
  }

  res = SWIG_ERROR;

  sobj = SWIG_Python_GetSwigThis(obj);
  if (own)
    *own = 0;
  while (sobj) {
    void *vptr = sobj->ptr;
    if (ty) {
      swig_type_info *to = sobj->ty;
      if (to == ty) {
        /* no type cast needed */
        if (ptr) *ptr = vptr;
        break;
      } else {
        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
        if (!tc) {
          sobj = (SwigPyObject *)sobj->next;
        } else {
          if (ptr) {
            int newmemory = 0;
            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
            if (newmemory == SWIG_CAST_NEW_MEMORY) {
              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
              if (own)
                *own = *own | SWIG_CAST_NEW_MEMORY;
            }
          }
          break;
        }
      }
    } else {
      if (ptr) *ptr = vptr;
      break;
    }
  }
  if (sobj) {
    if (own)
      *own = *own | sobj->own;
    if (flags & SWIG_POINTER_DISOWN) {
      sobj->own = 0;
    }
    res = SWIG_OK;
  } else {
    if (implicit_conv) {
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
      if (data && !data->implicitconv) {
        PyObject *klass = data->klass;
        if (klass) {
          PyObject *impconv;
          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
          impconv = SWIG_Python_CallFunctor(klass, obj);
          data->implicitconv = 0;
          if (PyErr_Occurred()) {
            PyErr_Clear();
            impconv = 0;
          }
          if (impconv) {
            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
            if (iobj) {
              void *vptr;
              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
              if (SWIG_IsOK(res)) {
                if (ptr) {
                  *ptr = vptr;
                  /* transfer the ownership to 'ptr' */
                  iobj->own = 0;
                  res = SWIG_AddCast(res);
                  res = SWIG_AddNewMask(res);
                } else {
                  res = SWIG_AddCast(res);		    
                }
              }
            }
            Py_DECREF(impconv);
          }
        }
      }
    }
    if (!SWIG_IsOK(res) && obj == Py_None) {
      if (ptr)
        *ptr = 0;
      if (PyErr_Occurred())
        PyErr_Clear();
      res = SWIG_OK;
    }
  }
  return res;
}

/* Convert a function ptr value */

SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
  if (!PyCFunction_Check(obj)) {
    return SWIG_ConvertPtr(obj, ptr, ty, 0);
  } else {
    void *vptr = 0;
    
    /* here we get the method pointer for callbacks */
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    if (desc)
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
    if (!desc) 
      return SWIG_ERROR;
    if (ty) {
      swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
      if (tc) {
        int newmemory = 0;
        *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
        assert(!newmemory); /* newmemory handling not yet implemented */
      } else {
        return SWIG_ERROR;
      }
    } else {
      *ptr = vptr;
    }
    return SWIG_OK;
  }
}

/* Convert a packed value value */

SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
  if (!to) return SWIG_ERROR;
  if (ty) {
    if (to != ty) {
      /* check type cast? */
      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
      if (!tc) return SWIG_ERROR;
    }
  }
  return SWIG_OK;
}  

/* -----------------------------------------------------------------------------
 * Create a new pointer object
 * ----------------------------------------------------------------------------- */

/*
  Create a new instance object, without calling __init__, and set the
  'this' attribute.
*/

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
#if (PY_VERSION_HEX >= 0x02020000)
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
	PyObject *dict = *dictptr;
	if (dict == NULL) {
	  dict = PyDict_New();
	  *dictptr = dict;
	  PyDict_SetItem(dict, SWIG_This(), swig_this);
	}
      }
#else
      PyObject *key = SWIG_This();
      PyObject_SetAttr(inst, key, swig_this);
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
    if (inst) {
      PyObject_SetAttr(inst, SWIG_This(), swig_this);
      Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      Py_DECREF(dict);
    }
#endif
  }
  return inst;
#else
#if (PY_VERSION_HEX >= 0x02010000)
  PyObject *inst = 0;
  PyObject *dict = PyDict_New();
  if (dict) {
    PyDict_SetItem(dict, SWIG_This(), swig_this);
    inst = PyInstance_NewRaw(data->newargs, dict);
    Py_DECREF(dict);
  }
  return (PyObject *) inst;
#else
  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
  if (inst == NULL) {
    return NULL;
  }
  inst->in_class = (PyClassObject *)data->newargs;
  Py_INCREF(inst->in_class);
  inst->in_dict = PyDict_New();
  if (inst->in_dict == NULL) {
    Py_DECREF(inst);
    return NULL;
  }
#ifdef Py_TPFLAGS_HAVE_WEAKREFS
  inst->in_weakreflist = NULL;
#endif
#ifdef Py_TPFLAGS_GC
  PyObject_GC_Init(inst);
#endif
  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
  return (PyObject *) inst;
#endif
#endif
}

SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
 PyObject *dict;
#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
 PyObject **dictptr = _PyObject_GetDictPtr(inst);
 if (dictptr != NULL) {
   dict = *dictptr;
   if (dict == NULL) {
     dict = PyDict_New();
     *dictptr = dict;
   }
   PyDict_SetItem(dict, SWIG_This(), swig_this);
   return;
 }
#endif
 dict = PyObject_GetAttrString(inst, (char*)"__dict__");
 PyDict_SetItem(dict, SWIG_This(), swig_this);
 Py_DECREF(dict);
} 


SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
  PyObject *obj[2];
  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    return NULL;
  } else {
    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    if (sthis) {
      SwigPyObject_append((PyObject*) sthis, obj[1]);
    } else {
      SWIG_Python_SetSwigThis(obj[0], obj[1]);
    }
    return SWIG_Py_Void();
  }
}

/* Create a new pointer object */

SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
  SwigPyClientData *clientdata;
  PyObject * robj;
  int own;

  if (!ptr)
    return SWIG_Py_Void();

  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
  if (clientdata && clientdata->pytype) {
    SwigPyObject *newobj;
    if (flags & SWIG_BUILTIN_TP_INIT) {
      newobj = (SwigPyObject*) self;
      if (newobj->ptr) {
        PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
        while (newobj->next)
	  newobj = (SwigPyObject *) newobj->next;
        newobj->next = next_self;
        newobj = (SwigPyObject *)next_self;
        newobj->parent = 0;
#ifdef SWIGPYTHON_BUILTIN
        newobj->dict = 0;
#endif
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
      newobj->parent = 0;
#ifdef SWIGPYTHON_BUILTIN
      newobj->dict = 0;
#endif
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

  robj = SwigPyObject_New(ptr, type, own);
  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    Py_DECREF(robj);
    robj = inst;
  }
  return robj;
}

/* Create a new packed object */

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}

/* -----------------------------------------------------------------------------*
 *  Get type list 
 * -----------------------------------------------------------------------------*/

#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif

SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
  static void *type_pointer = (void *)0;
  /* first check if module already created */
  if (!type_pointer) {
#ifdef SWIG_LINK_RUNTIME
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
#else
# ifdef SWIGPY_USE_CAPSULE
    type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
# else
    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
				    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
# endif
    if (PyErr_Occurred()) {
      PyErr_Clear();
      type_pointer = (void *)0;
    }
#endif
  }
  return (swig_module_info *) type_pointer;
}

#if PY_MAJOR_VERSION < 2
/* PyModule_AddObject function was introduced in Python 2.0.  The following function
   is copied out of Python/modsupport.c in python version 2.3.4 */
SWIGINTERN int
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
{
  PyObject *dict;
  if (!PyModule_Check(m)) {
    PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
    return SWIG_ERROR;
  }
  if (!o) {
    PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
    return SWIG_ERROR;
  }
  
  dict = PyModule_GetDict(m);
  if (dict == NULL) {
    /* Internal error -- modules must have a dict! */
    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
		 PyModule_GetName(m));
    return SWIG_ERROR;
  }
  if (PyDict_SetItemString(dict, name, o))
    return SWIG_ERROR;
  Py_DECREF(o);
  return SWIG_OK;
}
#endif

SWIGRUNTIME void
#ifdef SWIGPY_USE_CAPSULE
SWIG_Python_DestroyModule(PyObject *obj)
#else
SWIG_Python_DestroyModule(void *vptr)
#endif
{
#ifdef SWIGPY_USE_CAPSULE
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
#else
  swig_module_info *swig_module = (swig_module_info *) vptr;
#endif
  swig_type_info **types = swig_module->types;
  size_t i;
  for (i =0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      if (data) SwigPyClientData_Del(data);
    }
  }
  Py_DECREF(SWIG_This());
  swig_this = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
 /* Add a dummy module object into sys.modules */
  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
#ifdef SWIGPY_USE_CAPSULE
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && module) {
    PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
  } else {
    Py_XDECREF(pointer);
  }
#else
  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
  if (pointer && module) {
    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
  } else {
    Py_XDECREF(pointer);
  }
#endif
}

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
  return cache;
}

SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *key = SWIG_Python_str_FromChar(type); 
  PyObject *obj = PyDict_GetItem(cache, key);
  swig_type_info *descriptor;
  if (obj) {
#ifdef SWIGPY_USE_CAPSULE
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
#else
    descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
#endif
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
#ifdef SWIGPY_USE_CAPSULE
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
#else
      obj = PyCObject_FromVoidPtr(descriptor, NULL);
#endif
      PyDict_SetItem(cache, key, obj);
      Py_DECREF(obj);
    }
  }
  Py_DECREF(key);
  return descriptor;
}

/* 
   For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION  0
#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)

SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{  
  if (PyErr_Occurred()) {
    PyObject *type = 0;
    PyObject *value = 0;
    PyObject *traceback = 0;
    PyErr_Fetch(&type, &value, &traceback);
    if (value) {
      char *tmp;
      PyObject *old_str = PyObject_Str(value);
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
      } else {
	PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
      }
      SWIG_Python_str_DelForPy3(tmp);
      Py_DECREF(old_str);
    }
    return 1;
  } else {
    return 0;
  }
}
  
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
  if (PyErr_Occurred()) {
    /* add information about failing argument */
    char mesg[256];
    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    return SWIG_Python_AddErrMesg(mesg, 1);
  } else {
    return 0;
  }
}

SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
  SwigPyObject *v = (SwigPyObject *)self;
  swig_type_info *ty = v ? v->ty : 0;
  return ty ? ty->str : "";
}

SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
  if (type) {
#if defined(SWIG_COBJECT_TYPES)
    if (obj && SwigPyObject_Check(obj)) {
      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
      if (otype) {
	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
		     type, otype);
	return;
      }
    } else 
#endif      
    {
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, cstr);
          SWIG_Python_str_DelForPy3(cstr);
	} else {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
		       type, otype);
	}
	Py_XDECREF(str);
	return;
      }
    }   
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
  } else {
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
  }
}


/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
  void *result;
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    PyErr_Clear();
#if SWIG_POINTER_EXCEPTION
    if (flags) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
      SWIG_Python_ArgFail(argnum);
    }
#endif
  }
  return result;
}

#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
  PyTypeObject *tp = obj->ob_type;
  PyObject *descr;
  PyObject *encoded_name;
  descrsetfunc f;
  int res = -1;

# ifdef Py_USING_UNICODE
  if (PyString_Check(name)) {
    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    if (!name)
      return -1;
  } else if (!PyUnicode_Check(name))
# else
  if (!PyString_Check(name))
# endif
  {
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
    return -1;
  } else {
    Py_INCREF(name);
  }

  if (!tp->tp_dict) {
    if (PyType_Ready(tp) < 0)
      goto done;
  }

  descr = _PyType_Lookup(tp, name);
  f = NULL;
  if (descr != NULL)
    f = descr->ob_type->tp_descr_set;
  if (!f) {
    if (PyString_Check(name)) {
      encoded_name = name;
      Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
    }
    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  Py_DECREF(name);
  return res;
}
#endif


#ifdef __cplusplus
}
#endif

#ifdef __cplusplus
extern "C" {
#endif

SWIGINTERN Py_hash_t
SwigPyObject_hash(PyObject *obj) {
  SwigPyObject *sobj = (SwigPyObject *)obj;
  void *ptr = sobj->ptr;
  return (Py_hash_t)ptr;
}

SWIGINTERN Py_hash_t
SWIG_PyNumber_AsPyHash(PyObject *obj) {
  Py_hash_t result = -1;
#if PY_VERSION_HEX < 0x03020000
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj))
    result = PyInt_AsLong(obj);
  else
#endif
  if (PyLong_Check(obj))
    result = PyLong_AsLong(obj);
#else
  if (PyNumber_Check(obj))
    result = PyNumber_AsSsize_t(obj, NULL);
#endif
  else
    PyErr_Format(PyExc_TypeError, "Wrong type for hash function");
  return PyErr_Occurred() ? -1 : result;
}

SWIGINTERN int
SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
  PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
  return -1;
}

SWIGINTERN void
SwigPyBuiltin_BadDealloc(PyObject *obj) {
  SwigPyObject *sobj = (SwigPyObject *)obj;
  if (sobj->own) {
    PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", obj->ob_type->tp_name);
  }
}

typedef struct {
  PyCFunction get;
  PyCFunction set;
} SwigPyGetSet;

SWIGINTERN PyObject *
SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
  SwigPyGetSet *getset;
  PyObject *tuple, *result;
  if (!closure)
    return SWIG_Py_Void();
  getset = (SwigPyGetSet *)closure;
  if (!getset->get)
    return SWIG_Py_Void();
  tuple = PyTuple_New(0);
  assert(tuple);
  result = (*getset->get)(obj, tuple);
  Py_DECREF(tuple);
  return result;
}

SWIGINTERN PyObject *
SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
  SwigPyGetSet *getset;
  PyObject *result;
  if (!closure)
    return SWIG_Py_Void();
  getset = (SwigPyGetSet *)closure;
  if (!getset->get)
    return SWIG_Py_Void();
  result = (*getset->get)(obj, NULL);
  return result;
}

SWIGINTERN int
SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
  SwigPyGetSet *getset;
  PyObject *tuple, *result;
  if (!closure) {
    PyErr_Format(PyExc_TypeError, "Missing getset closure");
    return -1;
  }
  getset = (SwigPyGetSet *)closure;
  if (!getset->set) {
    PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
    return -1;
  }
  tuple = PyTuple_New(1);
  assert(tuple);
  PyTuple_SET_ITEM(tuple, 0, val);
  Py_XINCREF(val);
  result = (*getset->set)(obj, tuple);
  Py_DECREF(tuple);
  Py_XDECREF(result);
  return result ? 0 : -1;
}

SWIGINTERN int
SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
  SwigPyGetSet *getset;
  PyObject *result;
  if (!closure) {
    PyErr_Format(PyExc_TypeError, "Missing getset closure");
    return -1;
  }
  getset = (SwigPyGetSet *)closure;
  if (!getset->set) {
    PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
    return -1;
  }
  result = (*getset->set)(obj, val);
  Py_XDECREF(result);
  return result ? 0 : -1;
}

SWIGINTERN void
SwigPyStaticVar_dealloc(PyDescrObject *descr) {
  PyObject_GC_UnTrack(descr);
  Py_XDECREF(PyDescr_TYPE(descr));
  Py_XDECREF(PyDescr_NAME(descr));
  PyObject_GC_Del(descr);
}

SWIGINTERN PyObject *
SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
#if PY_VERSION_HEX >= 0x03000000

  return PyUnicode_FromFormat("<class attribute '%S' of type '%s'>", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
  return PyString_FromFormat("<class attribute '%s' of type '%s'>", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
}

SWIGINTERN int
SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
  PyDescrObject *descr;
  descr = (PyDescrObject *)self;
  Py_VISIT((PyObject*) PyDescr_TYPE(descr));
  return 0;
}

SWIGINTERN PyObject *
SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
  if (descr->d_getset->get != NULL)
    return descr->d_getset->get(obj, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
  PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
  PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
  return NULL;
}

SWIGINTERN int
SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
  if (descr->d_getset->set != NULL)
    return descr->d_getset->set(obj, value, descr->d_getset->closure);
#if PY_VERSION_HEX >= 0x03000000
  PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
#else
  PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
#endif
  return -1;
}

SWIGINTERN int
SwigPyObjectType_setattro(PyObject *typeobject, PyObject *name, PyObject *value) {
  PyObject *attribute;
  PyTypeObject *type;
  descrsetfunc local_set;

  assert(PyType_Check(typeobject));
  type = (PyTypeObject *)typeobject;
  attribute = _PyType_Lookup(type, name);
  if (attribute != NULL) {
    /* Implement descriptor functionality, if any */
    local_set = attribute->ob_type->tp_descr_set;
    if (local_set != NULL)
      return local_set(attribute, (PyObject *)type, value);
#if PY_VERSION_HEX >= 0x03000000
    PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
#else 
    PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
  } else {
#if PY_VERSION_HEX >= 0x03000000
    PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
#else
    PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
#endif
  }

  return -1;
}

SWIGINTERN PyTypeObject*
SwigPyStaticVar_Type(void) {
  static PyTypeObject staticvar_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
      PyObject_HEAD_INIT(&PyType_Type)
      0,                                        /* ob_size */
#endif
      "swig_static_var_getset_descriptor",      /* tp_name */
      sizeof(PyGetSetDescrObject),              /* tp_basicsize */
      0,                                        /* tp_itemsize */
      (destructor)SwigPyStaticVar_dealloc,      /* tp_dealloc */
      0,                                        /* tp_print */
      0,                                        /* tp_getattr */
      0,                                        /* tp_setattr */
      0,                                        /* tp_compare */
      (reprfunc)SwigPyStaticVar_repr,           /* tp_repr */
      0,                                        /* tp_as_number */
      0,                                        /* tp_as_sequence */
      0,                                        /* tp_as_mapping */
      0,                                        /* tp_hash */
      0,                                        /* tp_call */
      0,                                        /* tp_str */
      PyObject_GenericGetAttr,                  /* tp_getattro */
      0,                                        /* tp_setattro */
      0,                                        /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
      0,                                        /* tp_doc */
      SwigPyStaticVar_traverse,                 /* tp_traverse */
      0,                                        /* tp_clear */
      0,                                        /* tp_richcompare */
      0,                                        /* tp_weaklistoffset */
      0,                                        /* tp_iter */
      0,                                        /* tp_iternext */
      0,                                        /* tp_methods */
      0,                                        /* tp_members */
      0,                                        /* tp_getset */
      0,                                        /* tp_base */
      0,                                        /* tp_dict */
      (descrgetfunc)SwigPyStaticVar_get,        /* tp_descr_get */
      (descrsetfunc)SwigPyStaticVar_set,        /* tp_descr_set */
      0,                                        /* tp_dictoffset */
      0,                                        /* tp_init */
      0,                                        /* tp_alloc */
      0,                                        /* tp_new */
      0,                                        /* tp_free */
      0,                                        /* tp_is_gc */
      0,                                        /* tp_bases */
      0,                                        /* tp_mro */
      0,                                        /* tp_cache */
      0,                                        /* tp_subclasses */
      0,                                        /* tp_weaklist */
#if PY_VERSION_HEX >= 0x02030000
      0,                                        /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
      0,                                        /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
      0,                                        /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
      0,                                        /* tp_allocs */
      0,                                        /* tp_frees */
      0,                                        /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
      0,                                        /* tp_prev */
#endif
      0                                         /* tp_next */
#endif
    };
    staticvar_type = tmp;
    type_init = 1;
#if PY_VERSION_HEX < 0x02020000
    staticvar_type.ob_type = &PyType_Type;
#else
    if (PyType_Ready(&staticvar_type) < 0)
      return NULL;
#endif
  }
  return &staticvar_type;
}

SWIGINTERN PyTypeObject*
SwigPyObjectType(void) {
  static char swigpyobjecttype_doc[] = "Metaclass for SWIG wrapped types";
  static PyTypeObject swigpyobjecttype_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(&PyType_Type, 0)
#else
      PyObject_HEAD_INIT(&PyType_Type)
      0,                                        /* ob_size */
#endif
      "SwigPyObjectType",                       /* tp_name */
      PyType_Type.tp_basicsize,                 /* tp_basicsize */
      0,                                        /* tp_itemsize */
      0,                                        /* tp_dealloc */
      0,                                        /* tp_print */
      0,                                        /* tp_getattr */
      0,                                        /* tp_setattr */
      0,                                        /* tp_compare */
      0,                                        /* tp_repr */
      0,                                        /* tp_as_number */
      0,                                        /* tp_as_sequence */
      0,                                        /* tp_as_mapping */
      0,                                        /* tp_hash */
      0,                                        /* tp_call */
      0,                                        /* tp_str */
      0,                                        /* tp_getattro */
      SwigPyObjectType_setattro,                /* tp_setattro */
      0,                                        /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
      swigpyobjecttype_doc,                     /* tp_doc */
      0,                                        /* tp_traverse */
      0,                                        /* tp_clear */
      0,                                        /* tp_richcompare */
      0,                                        /* tp_weaklistoffset */
      0,                                        /* tp_iter */
      0,                                        /* tp_iternext */
      0,                                        /* tp_methods */
      0,                                        /* tp_members */
      0,                                        /* tp_getset */
      0,                                        /* tp_base */
      0,                                        /* tp_dict */
      0,                                        /* tp_descr_get */
      0,                                        /* tp_descr_set */
      0,                                        /* tp_dictoffset */
      0,                                        /* tp_init */
      0,                                        /* tp_alloc */
      0,                                        /* tp_new */
      0,                                        /* tp_free */
      0,                                        /* tp_is_gc */
      0,                                        /* tp_bases */
      0,                                        /* tp_mro */
      0,                                        /* tp_cache */
      0,                                        /* tp_subclasses */
      0,                                        /* tp_weaklist */
#if PY_VERSION_HEX >= 0x02030000
      0,                                        /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
      0,                                        /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
      0,                                        /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
      0,                                        /* tp_allocs */
      0,                                        /* tp_frees */
      0,                                        /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
      0,                                        /* tp_prev */
#endif
      0                                         /* tp_next */
#endif
    };
    swigpyobjecttype_type = tmp;
    type_init = 1;
    swigpyobjecttype_type.tp_base = &PyType_Type;
#if PY_VERSION_HEX < 0x02020000
    swigpyobjecttype_type.ob_type = &PyType_Type;
#else
    if (PyType_Ready(&swigpyobjecttype_type) < 0)
      return NULL;
#endif
  }
  return &swigpyobjecttype_type;
}

SWIGINTERN PyGetSetDescrObject *
SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {

  PyGetSetDescrObject *descr;
  descr = (PyGetSetDescrObject *)PyType_GenericAlloc(SwigPyStaticVar_Type(), 0);
  assert(descr);
  Py_XINCREF(type);
  PyDescr_TYPE(descr) = type;
  PyDescr_NAME(descr) = PyString_InternFromString(getset->name);
  descr->d_getset = getset;
  if (PyDescr_NAME(descr) == NULL) {
    Py_DECREF(descr);
    descr = NULL;
  }
  return descr;
}

SWIGINTERN void
SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
  int base_count = 0;
  PyTypeObject **b;
  PyObject *tuple;
  int i;

  if (!bases[0]) {
    bases[0] = SwigPyObject_type();
    bases[1] = NULL;
  }
  type->tp_base = bases[0];
  Py_INCREF((PyObject *)bases[0]);
  for (b = bases; *b != NULL; ++b)
    ++base_count;
  tuple = PyTuple_New(base_count);
  for (i = 0; i < base_count; ++i) {
    PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
    Py_INCREF((PyObject *)bases[i]);
  }
  type->tp_bases = tuple;
}

SWIGINTERN PyObject *
SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
  PyObject *result;
  result = (PyObject *)SWIG_Python_GetSwigThis(self);
  Py_XINCREF(result);
  return result;
}

SWIGINTERN void
SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
{
#if PY_VERSION_HEX >= 0x03000000
    type->ob_base.ob_base.ob_type = metatype;
#else
    type->ob_type = metatype;
#endif
}


/* Start of callback function macros for use in PyTypeObject */

typedef PyObject *(*SwigPyWrapperFunction)(PyObject *, PyObject *);

#define SWIGPY_UNARYFUNC_CLOSURE(wrapper)		\
SWIGINTERN PyObject *					\
wrapper##_unaryfunc_closure(PyObject *a) {		\
  return SwigPyBuiltin_unaryfunc_closure(wrapper, a);	\
}
SWIGINTERN PyObject *
SwigPyBuiltin_unaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
  return wrapper(a, NULL);
}

#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper)			\
SWIGINTERN void							\
wrapper##_destructor_closure(PyObject *a) {			\
    SwigPyBuiltin_destructor_closure(wrapper, #wrapper, a);	\
}
SWIGINTERN void
SwigPyBuiltin_destructor_closure(SwigPyWrapperFunction wrapper, const char *wrappername, PyObject *a) {
  SwigPyObject *sobj;
  sobj = (SwigPyObject *)a;
  Py_XDECREF(sobj->dict);
  Py_XDECREF(sobj->parent);
  if (sobj->own) {
    PyObject *o;
    PyObject *val = 0, *type = 0, *tb = 0;
    PyErr_Fetch(&val, &type, &tb);
    o = wrapper(a, NULL);
    if (!o) {
      PyObject *deallocname = PyString_FromString(wrappername);
      PyErr_WriteUnraisable(deallocname);
      Py_DECREF(deallocname);
    }
    PyErr_Restore(val, type, tb);
    Py_XDECREF(o);
  }
  if (PyType_IS_GC(a->ob_type)) {
    PyObject_GC_Del(a);
  } else {
    PyObject_Del(a);
  }
}

#define SWIGPY_INQUIRY_CLOSURE(wrapper)			\
SWIGINTERN int						\
wrapper##_inquiry_closure(PyObject *a) {		\
  return SwigPyBuiltin_inquiry_closure(wrapper, a);	\
}
SWIGINTERN int
SwigPyBuiltin_inquiry_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
  PyObject *pyresult;
  int result;
  pyresult = wrapper(a, NULL);
  result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;
  Py_XDECREF(pyresult);
  return result;
}

#define SWIGPY_GETITERFUNC_CLOSURE(wrapper)		\
SWIGINTERN PyObject *					\
wrapper##_getiterfunc_closure(PyObject *a) {		\
  return SwigPyBuiltin_getiterfunc_closure(wrapper, a);	\
}
SWIGINTERN PyObject *
SwigPyBuiltin_getiterfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
  return wrapper(a, NULL);
}

#define SWIGPY_BINARYFUNC_CLOSURE(wrapper)			\
SWIGINTERN PyObject *						\
wrapper##_binaryfunc_closure(PyObject *a, PyObject *b) {	\
  return SwigPyBuiltin_binaryfunc_closure(wrapper, a, b);	\
}
SWIGINTERN PyObject *
SwigPyBuiltin_binaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
  PyObject *tuple, *result;
  tuple = PyTuple_New(1);
  assert(tuple);
  PyTuple_SET_ITEM(tuple, 0, b);
  Py_XINCREF(b);
  result = wrapper(a, tuple);
  Py_DECREF(tuple);
  return result;
}

typedef ternaryfunc ternarycallfunc;

#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper)				\
SWIGINTERN PyObject *							\
wrapper##_ternaryfunc_closure(PyObject *a, PyObject *b, PyObject *c) {	\
  return SwigPyBuiltin_ternaryfunc_closure(wrapper, a, b, c);		\
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
  PyObject *tuple, *result;
  tuple = PyTuple_New(2);
  assert(tuple);
  PyTuple_SET_ITEM(tuple, 0, b);
  PyTuple_SET_ITEM(tuple, 1, c);
  Py_XINCREF(b);
  Py_XINCREF(c);
  result = wrapper(a, tuple);
  Py_DECREF(tuple);
  return result;
}

#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper)					\
SWIGINTERN PyObject *								\
wrapper##_ternarycallfunc_closure(PyObject *a, PyObject *b, PyObject *c) {	\
  return SwigPyBuiltin_ternarycallfunc_closure(wrapper, a, b, c);		\
}
SWIGINTERN PyObject *
SwigPyBuiltin_ternarycallfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
  (void) c;
  return wrapper(a, b);
}

#define SWIGPY_LENFUNC_CLOSURE(wrapper)			\
SWIGINTERN Py_ssize_t					\
wrapper##_lenfunc_closure(PyObject *a) {		\
  return SwigPyBuiltin_lenfunc_closure(wrapper, a);	\
}
SWIGINTERN Py_ssize_t
SwigPyBuiltin_lenfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
  PyObject *resultobj;
  Py_ssize_t result;
  resultobj = wrapper(a, NULL);
  result = PyNumber_AsSsize_t(resultobj, NULL);
  Py_DECREF(resultobj);
  return result;
}

#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper)				\
SWIGINTERN PyObject *								\
wrapper##_ssizessizeargfunc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) {	\
  return SwigPyBuiltin_ssizessizeargfunc_closure(wrapper, a, b, c);		\
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizessizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c) {
  PyObject *tuple, *result;
  tuple = PyTuple_New(2);
  assert(tuple);
  PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
  PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
  result = wrapper(a, tuple);
  Py_DECREF(tuple);
  return result;
}

#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper)						\
SWIGINTERN int											\
wrapper##_ssizessizeobjargproc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {	\
  return SwigPyBuiltin_ssizessizeobjargproc_closure(wrapper, a, b, c, d);			\
}
SWIGINTERN int
SwigPyBuiltin_ssizessizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {
  PyObject *tuple, *resultobj;
  int result;
  tuple = PyTuple_New(d ? 3 : 2);
  assert(tuple);
  PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
  PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
  if (d) {
    PyTuple_SET_ITEM(tuple, 2, d);
    Py_INCREF(d);
  }
  resultobj = wrapper(a, tuple);
  result = resultobj ? 0 : -1;
  Py_DECREF(tuple);
  Py_XDECREF(resultobj);
  return result;
}

#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper)				\
SWIGINTERN PyObject *							\
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) {		\
  return SwigPyBuiltin_funpack_ssizeargfunc_closure(wrapper, a, b);	\
}
SWIGINTERN PyObject *
SwigPyBuiltin_funpack_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
  PyObject *tuple, *result;
  tuple = PyTuple_New(1);
  assert(tuple);
  PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
  result = wrapper(a, tuple);
  Py_DECREF(tuple);
  return result;
}

#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper)			\
SWIGINTERN PyObject *							\
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) {		\
  return SwigPyBuiltin_ssizeargfunc_closure(wrapper, a, b);		\
}
SWIGINTERN PyObject *
SwigPyBuiltin_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
  PyObject *arg, *result;
  arg = _PyLong_FromSsize_t(b);
  result = wrapper(a, arg);
  Py_DECREF(arg);
  return result;
}

#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper)					\
SWIGINTERN int									\
wrapper##_ssizeobjargproc_closure(PyObject *a, Py_ssize_t b, PyObject *c) {	\
  return SwigPyBuiltin_ssizeobjargproc_closure(wrapper, a, b, c);		\
}
SWIGINTERN int
SwigPyBuiltin_ssizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, PyObject *c) {
  PyObject *tuple, *resultobj;
  int result;
  tuple = PyTuple_New(2);
  assert(tuple);
  PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
  PyTuple_SET_ITEM(tuple, 1, c);
  Py_XINCREF(c);
  resultobj = wrapper(a, tuple);
  result = resultobj ? 0 : -1;
  Py_XDECREF(resultobj);
  Py_DECREF(tuple);
  return result;
}

#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper)					\
SWIGINTERN int									\
wrapper##_objobjargproc_closure(PyObject *a, PyObject *b, PyObject *c) {	\
  return SwigPyBuiltin_objobjargproc_closure(wrapper, a, b, c);			\
}
SWIGINTERN int
SwigPyBuiltin_objobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
  PyObject *tuple, *resultobj;
  int result;
  tuple = PyTuple_New(c ? 2 : 1);
  assert(tuple);
  PyTuple_SET_ITEM(tuple, 0, b);
  Py_XINCREF(b);
  if (c) {
    PyTuple_SET_ITEM(tuple, 1, c);
    Py_XINCREF(c);
  }
  resultobj = wrapper(a, tuple);
  result = resultobj ? 0 : -1;
  Py_XDECREF(resultobj);
  Py_DECREF(tuple);
  return result;
}

#define SWIGPY_REPRFUNC_CLOSURE(wrapper)		\
SWIGINTERN PyObject *					\
wrapper##_reprfunc_closure(PyObject *a) {		\
  return SwigPyBuiltin_reprfunc_closure(wrapper, a);	\
}
SWIGINTERN PyObject *
SwigPyBuiltin_reprfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
  return wrapper(a, NULL);
}

#define SWIGPY_HASHFUNC_CLOSURE(wrapper)		\
SWIGINTERN Py_hash_t					\
wrapper##_hashfunc_closure(PyObject *a) {		\
  return SwigPyBuiltin_hashfunc_closure(wrapper, a);	\
}
SWIGINTERN Py_hash_t
SwigPyBuiltin_hashfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
  PyObject *pyresult;
  Py_hash_t result;
  pyresult = wrapper(a, NULL);
  if (!pyresult)
    return -1;
  result = SWIG_PyNumber_AsPyHash(pyresult);
  Py_DECREF(pyresult);
  return result;
}

#define SWIGPY_ITERNEXTFUNC_CLOSURE(wrapper)		\
SWIGINTERN PyObject *					\
wrapper##_iternextfunc_closure(PyObject *a) {		\
  return SwigPyBuiltin_iternextfunc_closure(wrapper, a);\
}
SWIGINTERN PyObject *
SwigPyBuiltin_iternextfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
  return wrapper(a, NULL);
}

/* End of callback function macros for use in PyTypeObject */

#ifdef __cplusplus
}
#endif




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

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



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

#define SWIGTYPE_p_ANativeWindow swig_types[0]
#define SWIGTYPE_p_APIEvent swig_types[1]
#define SWIGTYPE_p_APIProperties swig_types[2]
#define SWIGTYPE_p_APIUseData swig_types[3]
#define SWIGTYPE_p_ActionDescription swig_types[4]
#define SWIGTYPE_p_ActionFlags swig_types[5]
#define SWIGTYPE_p_AddressMode swig_types[6]
#define SWIGTYPE_p_AlphaMapping swig_types[7]
#define SWIGTYPE_p_AndroidFlags swig_types[8]
#define SWIGTYPE_p_AxisMapping swig_types[9]
#define SWIGTYPE_p_BindType swig_types[10]
#define SWIGTYPE_p_BlendEquation swig_types[11]
#define SWIGTYPE_p_BlendMultiplier swig_types[12]
#define SWIGTYPE_p_BlendOperation swig_types[13]
#define SWIGTYPE_p_BlendStats swig_types[14]
#define SWIGTYPE_p_BoundVBuffer swig_types[15]
#define SWIGTYPE_p_BucketRecordType swig_types[16]
#define SWIGTYPE_p_BufferCategory swig_types[17]
#define SWIGTYPE_p_BufferDescription swig_types[18]
#define SWIGTYPE_p_BusyData swig_types[19]
#define SWIGTYPE_p_CameraType swig_types[20]
#define SWIGTYPE_p_CaptureFileFormat swig_types[21]
#define SWIGTYPE_p_CaptureOptions swig_types[22]
#define SWIGTYPE_p_ChromaSampleLocation swig_types[23]
#define SWIGTYPE_p_ColorBlend swig_types[24]
#define SWIGTYPE_p_CompType swig_types[25]
#define SWIGTYPE_p_CompareFunction swig_types[26]
#define SWIGTYPE_p_ConservativeRaster swig_types[27]
#define SWIGTYPE_p_ConstantBindStats swig_types[28]
#define SWIGTYPE_p_ConstantBlock swig_types[29]
#define SWIGTYPE_p_CounterDescription swig_types[30]
#define SWIGTYPE_p_CounterResult swig_types[31]
#define SWIGTYPE_p_CounterUnit swig_types[32]
#define SWIGTYPE_p_CounterValue swig_types[33]
#define SWIGTYPE_p_CullMode swig_types[34]
#define SWIGTYPE_p_D3D11Pipe__BlendState swig_types[35]
#define SWIGTYPE_p_D3D11Pipe__DepthStencilState swig_types[36]
#define SWIGTYPE_p_D3D11Pipe__IndexBuffer swig_types[37]
#define SWIGTYPE_p_D3D11Pipe__InputAssembly swig_types[38]
#define SWIGTYPE_p_D3D11Pipe__Layout swig_types[39]
#define SWIGTYPE_p_D3D11Pipe__OutputMerger swig_types[40]
#define SWIGTYPE_p_D3D11Pipe__Predication swig_types[41]
#define SWIGTYPE_p_D3D11Pipe__Rasterizer swig_types[42]
#define SWIGTYPE_p_D3D11Pipe__RasterizerState swig_types[43]
#define SWIGTYPE_p_D3D11Pipe__Shader swig_types[44]
#define SWIGTYPE_p_D3D11Pipe__State swig_types[45]
#define SWIGTYPE_p_D3D11Pipe__StreamOut swig_types[46]
#define SWIGTYPE_p_D3D11Pipe__StreamOutBind swig_types[47]
#define SWIGTYPE_p_D3D11Pipe__VertexBuffer swig_types[48]
#define SWIGTYPE_p_D3D12Pipe__BlendState swig_types[49]
#define SWIGTYPE_p_D3D12Pipe__DepthStencilState swig_types[50]
#define SWIGTYPE_p_D3D12Pipe__IndexBuffer swig_types[51]
#define SWIGTYPE_p_D3D12Pipe__InputAssembly swig_types[52]
#define SWIGTYPE_p_D3D12Pipe__Layout swig_types[53]
#define SWIGTYPE_p_D3D12Pipe__OM swig_types[54]
#define SWIGTYPE_p_D3D12Pipe__Predication swig_types[55]
#define SWIGTYPE_p_D3D12Pipe__Rasterizer swig_types[56]
#define SWIGTYPE_p_D3D12Pipe__RasterizerState swig_types[57]
#define SWIGTYPE_p_D3D12Pipe__ResourceData swig_types[58]
#define SWIGTYPE_p_D3D12Pipe__ResourceState swig_types[59]
#define SWIGTYPE_p_D3D12Pipe__RootParam swig_types[60]
#define SWIGTYPE_p_D3D12Pipe__RootSignature swig_types[61]
#define SWIGTYPE_p_D3D12Pipe__RootTableRange swig_types[62]
#define SWIGTYPE_p_D3D12Pipe__Shader swig_types[63]
#define SWIGTYPE_p_D3D12Pipe__State swig_types[64]
#define SWIGTYPE_p_D3D12Pipe__StaticSampler swig_types[65]
#define SWIGTYPE_p_D3D12Pipe__StreamOut swig_types[66]
#define SWIGTYPE_p_D3D12Pipe__StreamOutBind swig_types[67]
#define SWIGTYPE_p_D3D12Pipe__VertexBuffer swig_types[68]
#define SWIGTYPE_p_DebugMessage swig_types[69]
#define SWIGTYPE_p_DebugOverlay swig_types[70]
#define SWIGTYPE_p_DebugPixelInputs swig_types[71]
#define SWIGTYPE_p_DebugVariableReference swig_types[72]
#define SWIGTYPE_p_DebugVariableType swig_types[73]
#define SWIGTYPE_p_DepthStencilStats swig_types[74]
#define SWIGTYPE_p_DepthTestState swig_types[75]
#define SWIGTYPE_p_Descriptor swig_types[76]
#define SWIGTYPE_p_DescriptorAccess swig_types[77]
#define SWIGTYPE_p_DescriptorCategory swig_types[78]
#define SWIGTYPE_p_DescriptorFlags swig_types[79]
#define SWIGTYPE_p_DescriptorLogicalLocation swig_types[80]
#define SWIGTYPE_p_DescriptorRange swig_types[81]
#define SWIGTYPE_p_DescriptorStoreDescription swig_types[82]
#define SWIGTYPE_p_DescriptorType swig_types[83]
#define SWIGTYPE_p_DispatchStats swig_types[84]
#define SWIGTYPE_p_DrawcallStats swig_types[85]
#define SWIGTYPE_p_DriverInformation swig_types[86]
#define SWIGTYPE_p_EnvMod swig_types[87]
#define SWIGTYPE_p_EnvSep swig_types[88]
#define SWIGTYPE_p_EnvironmentModification swig_types[89]
#define SWIGTYPE_p_EventUsage swig_types[90]
#define SWIGTYPE_p_ExecuteResult swig_types[91]
#define SWIGTYPE_p_FileType swig_types[92]
#define SWIGTYPE_p_FillMode swig_types[93]
#define SWIGTYPE_p_FilterFunction swig_types[94]
#define SWIGTYPE_p_FilterMode swig_types[95]
#define SWIGTYPE_p_FloatVector swig_types[96]
#define SWIGTYPE_p_FrameDescription swig_types[97]
#define SWIGTYPE_p_FrameStatistics swig_types[98]
#define SWIGTYPE_p_GLPipe__BlendState swig_types[99]
#define SWIGTYPE_p_GLPipe__DepthState swig_types[100]
#define SWIGTYPE_p_GLPipe__FBO swig_types[101]
#define SWIGTYPE_p_GLPipe__Feedback swig_types[102]
#define SWIGTYPE_p_GLPipe__FixedVertexProcessing swig_types[103]
#define SWIGTYPE_p_GLPipe__FrameBuffer swig_types[104]
#define SWIGTYPE_p_GLPipe__Hints swig_types[105]
#define SWIGTYPE_p_GLPipe__Rasterizer swig_types[106]
#define SWIGTYPE_p_GLPipe__RasterizerState swig_types[107]
#define SWIGTYPE_p_GLPipe__Shader swig_types[108]
#define SWIGTYPE_p_GLPipe__State swig_types[109]
#define SWIGTYPE_p_GLPipe__StencilState swig_types[110]
#define SWIGTYPE_p_GLPipe__TextureCompleteness swig_types[111]
#define SWIGTYPE_p_GLPipe__VertexAttribute swig_types[112]
#define SWIGTYPE_p_GLPipe__VertexBuffer swig_types[113]
#define SWIGTYPE_p_GLPipe__VertexInput swig_types[114]
#define SWIGTYPE_p_GPUCounter swig_types[115]
#define SWIGTYPE_p_GPUDevice swig_types[116]
#define SWIGTYPE_p_GPUVendor swig_types[117]
#define SWIGTYPE_p_GlobalEnvironment swig_types[118]
#define SWIGTYPE_p_GraphicsAPI swig_types[119]
#define SWIGTYPE_p_HWND__ swig_types[120]
#define SWIGTYPE_p_ICamera swig_types[121]
#define SWIGTYPE_p_ICaptureAccess swig_types[122]
#define SWIGTYPE_p_ICaptureFile swig_types[123]
#define SWIGTYPE_p_IDeviceProtocolController swig_types[124]
#define SWIGTYPE_p_IRemoteServer swig_types[125]
#define SWIGTYPE_p_IReplayController swig_types[126]
#define SWIGTYPE_p_IReplayOutput swig_types[127]
#define SWIGTYPE_p_ITargetControl swig_types[128]
#define SWIGTYPE_p_IndexBindStats swig_types[129]
#define SWIGTYPE_p_InstructionSourceInfo swig_types[130]
#define SWIGTYPE_p_KnownShaderTool swig_types[131]
#define SWIGTYPE_p_LayoutBindStats swig_types[132]
#define SWIGTYPE_p_LineColumnInfo swig_types[133]
#define SWIGTYPE_p_LineRaster swig_types[134]
#define SWIGTYPE_p_LogType swig_types[135]
#define SWIGTYPE_p_LogicOperation swig_types[136]
#define SWIGTYPE_p_MeshDataStage swig_types[137]
#define SWIGTYPE_p_MeshDisplay swig_types[138]
#define SWIGTYPE_p_MeshFormat swig_types[139]
#define SWIGTYPE_p_MeshletSize swig_types[140]
#define SWIGTYPE_p_MessageCategory swig_types[141]
#define SWIGTYPE_p_MessageSeverity swig_types[142]
#define SWIGTYPE_p_MessageSource swig_types[143]
#define SWIGTYPE_p_ModificationValue swig_types[144]
#define SWIGTYPE_p_NewCaptureData swig_types[145]
#define SWIGTYPE_p_NewChildData swig_types[146]
#define SWIGTYPE_p_Offset swig_types[147]
#define SWIGTYPE_p_OutputTargetStats swig_types[148]
#define SWIGTYPE_p_PathEntry swig_types[149]
#define SWIGTYPE_p_PathProperty swig_types[150]
#define SWIGTYPE_p_PipeState swig_types[151]
#define SWIGTYPE_p_PixelModification swig_types[152]
#define SWIGTYPE_p_PixelValue swig_types[153]
#define SWIGTYPE_p_PointerVal swig_types[154]
#define SWIGTYPE_p_QualityHint swig_types[155]
#define SWIGTYPE_p_RasterState swig_types[156]
#define SWIGTYPE_p_RasterizationStats swig_types[157]
#define SWIGTYPE_p_ReplayOptimisationLevel swig_types[158]
#define SWIGTYPE_p_ReplayOptions swig_types[159]
#define SWIGTYPE_p_ReplayOutputType swig_types[160]
#define SWIGTYPE_p_ReplaySupport swig_types[161]
#define SWIGTYPE_p_ResourceBindStats swig_types[162]
#define SWIGTYPE_p_ResourceDescription swig_types[163]
#define SWIGTYPE_p_ResourceFormat swig_types[164]
#define SWIGTYPE_p_ResourceFormatType swig_types[165]
#define SWIGTYPE_p_ResourceId swig_types[166]
#define SWIGTYPE_p_ResourceType swig_types[167]
#define SWIGTYPE_p_ResourceUpdateStats swig_types[168]
#define SWIGTYPE_p_ResourceUsage swig_types[169]
#define SWIGTYPE_p_ResultCode swig_types[170]
#define SWIGTYPE_p_ResultDetails swig_types[171]
#define SWIGTYPE_p_SDBasic swig_types[172]
#define SWIGTYPE_p_SDChunk swig_types[173]
#define SWIGTYPE_p_SDChunkFlags swig_types[174]
#define SWIGTYPE_p_SDChunkMetaData swig_types[175]
#define SWIGTYPE_p_SDFile swig_types[176]
#define SWIGTYPE_p_SDObject swig_types[177]
#define SWIGTYPE_p_SDObjectData swig_types[178]
#define SWIGTYPE_p_SDObjectPODData swig_types[179]
#define SWIGTYPE_p_SDType swig_types[180]
#define SWIGTYPE_p_SDTypeFlags swig_types[181]
#define SWIGTYPE_p_SamplerBindStats swig_types[182]
#define SWIGTYPE_p_SamplerDescriptor swig_types[183]
#define SWIGTYPE_p_Scissor swig_types[184]
#define SWIGTYPE_p_SectionFlags swig_types[185]
#define SWIGTYPE_p_SectionProperties swig_types[186]
#define SWIGTYPE_p_SectionType swig_types[187]
#define SWIGTYPE_p_ShaderBindIndex swig_types[188]
#define SWIGTYPE_p_ShaderBuiltin swig_types[189]
#define SWIGTYPE_p_ShaderChangeStats swig_types[190]
#define SWIGTYPE_p_ShaderCompileFlag swig_types[191]
#define SWIGTYPE_p_ShaderCompileFlags swig_types[192]
#define SWIGTYPE_p_ShaderComputeMessageLocation swig_types[193]
#define SWIGTYPE_p_ShaderConstant swig_types[194]
#define SWIGTYPE_p_ShaderConstantType swig_types[195]
#define SWIGTYPE_p_ShaderDebugInfo swig_types[196]
#define SWIGTYPE_p_ShaderDebugState swig_types[197]
#define SWIGTYPE_p_ShaderDebugTrace swig_types[198]
#define SWIGTYPE_p_ShaderDebugger swig_types[199]
#define SWIGTYPE_p_ShaderDirectAccess swig_types[200]
#define SWIGTYPE_p_ShaderEncoding swig_types[201]
#define SWIGTYPE_p_ShaderEntryPoint swig_types[202]
#define SWIGTYPE_p_ShaderEvents swig_types[203]
#define SWIGTYPE_p_ShaderGeometryMessageLocation swig_types[204]
#define SWIGTYPE_p_ShaderMeshMessageLocation swig_types[205]
#define SWIGTYPE_p_ShaderMessage swig_types[206]
#define SWIGTYPE_p_ShaderMessageLocation swig_types[207]
#define SWIGTYPE_p_ShaderPixelMessageLocation swig_types[208]
#define SWIGTYPE_p_ShaderReflection swig_types[209]
#define SWIGTYPE_p_ShaderResource swig_types[210]
#define SWIGTYPE_p_ShaderSampler swig_types[211]
#define SWIGTYPE_p_ShaderSourceFile swig_types[212]
#define SWIGTYPE_p_ShaderSourcePrefix swig_types[213]
#define SWIGTYPE_p_ShaderStage swig_types[214]
#define SWIGTYPE_p_ShaderStageMask swig_types[215]
#define SWIGTYPE_p_ShaderValue swig_types[216]
#define SWIGTYPE_p_ShaderVariable swig_types[217]
#define SWIGTYPE_p_ShaderVariableChange swig_types[218]
#define SWIGTYPE_p_ShaderVariableFlags swig_types[219]
#define SWIGTYPE_p_ShaderVertexMessageLocation swig_types[220]
#define SWIGTYPE_p_ShadingRateCombiner swig_types[221]
#define SWIGTYPE_p_SigParameter swig_types[222]
#define SWIGTYPE_p_SourceVariableMapping swig_types[223]
#define SWIGTYPE_p_StencilFace swig_types[224]
#define SWIGTYPE_p_StencilOperation swig_types[225]
#define SWIGTYPE_p_StructuredBufferList swig_types[226]
#define SWIGTYPE_p_StructuredChunkList swig_types[227]
#define SWIGTYPE_p_StructuredObjectList swig_types[228]
#define SWIGTYPE_p_Subresource swig_types[229]
#define SWIGTYPE_p_SwigPyObject swig_types[230]
#define SWIGTYPE_p_TargetControlMessage swig_types[231]
#define SWIGTYPE_p_TargetControlMessageType swig_types[232]
#define SWIGTYPE_p_TaskGroupSize swig_types[233]
#define SWIGTYPE_p_TextureCategory swig_types[234]
#define SWIGTYPE_p_TextureComponentMapping swig_types[235]
#define SWIGTYPE_p_TextureDescription swig_types[236]
#define SWIGTYPE_p_TextureDisplay swig_types[237]
#define SWIGTYPE_p_TextureFilter swig_types[238]
#define SWIGTYPE_p_TextureSampleMapping swig_types[239]
#define SWIGTYPE_p_TextureSave swig_types[240]
#define SWIGTYPE_p_TextureSliceMapping swig_types[241]
#define SWIGTYPE_p_TextureSwizzle swig_types[242]
#define SWIGTYPE_p_TextureSwizzle4 swig_types[243]
#define SWIGTYPE_p_TextureType swig_types[244]
#define SWIGTYPE_p_Thumbnail swig_types[245]
#define SWIGTYPE_p_Topology swig_types[246]
#define SWIGTYPE_p_UsedDescriptor swig_types[247]
#define SWIGTYPE_p_Uuid swig_types[248]
#define SWIGTYPE_p_VKPipe__ColorBlendState swig_types[249]
#define SWIGTYPE_p_VKPipe__ConditionalRendering swig_types[250]
#define SWIGTYPE_p_VKPipe__CurrentPass swig_types[251]
#define SWIGTYPE_p_VKPipe__DepthStencil swig_types[252]
#define SWIGTYPE_p_VKPipe__DescriptorBuffer swig_types[253]
#define SWIGTYPE_p_VKPipe__DescriptorSet swig_types[254]
#define SWIGTYPE_p_VKPipe__DynamicOffset swig_types[255]
#define SWIGTYPE_p_VKPipe__Framebuffer swig_types[256]
#define SWIGTYPE_p_VKPipe__ImageData swig_types[257]
#define SWIGTYPE_p_VKPipe__ImageLayout swig_types[258]
#define SWIGTYPE_p_VKPipe__IndexBuffer swig_types[259]
#define SWIGTYPE_p_VKPipe__InputAssembly swig_types[260]
#define SWIGTYPE_p_VKPipe__MultiSample swig_types[261]
#define SWIGTYPE_p_VKPipe__Pipeline swig_types[262]
#define SWIGTYPE_p_VKPipe__Rasterizer swig_types[263]
#define SWIGTYPE_p_VKPipe__RenderArea swig_types[264]
#define SWIGTYPE_p_VKPipe__RenderPass swig_types[265]
#define SWIGTYPE_p_VKPipe__SampleLocations swig_types[266]
#define SWIGTYPE_p_VKPipe__Shader swig_types[267]
#define SWIGTYPE_p_VKPipe__State swig_types[268]
#define SWIGTYPE_p_VKPipe__Tessellation swig_types[269]
#define SWIGTYPE_p_VKPipe__TransformFeedback swig_types[270]
#define SWIGTYPE_p_VKPipe__VertexAttribute swig_types[271]
#define SWIGTYPE_p_VKPipe__VertexBinding swig_types[272]
#define SWIGTYPE_p_VKPipe__VertexBuffer swig_types[273]
#define SWIGTYPE_p_VKPipe__VertexInput swig_types[274]
#define SWIGTYPE_p_VKPipe__ViewState swig_types[275]
#define SWIGTYPE_p_VKPipe__ViewportScissor swig_types[276]
#define SWIGTYPE_p_VKPipe__XFBBuffer swig_types[277]
#define SWIGTYPE_p_VarType swig_types[278]
#define SWIGTYPE_p_VertexBindStats swig_types[279]
#define SWIGTYPE_p_VertexInputAttribute swig_types[280]
#define SWIGTYPE_p_Viewport swig_types[281]
#define SWIGTYPE_p_Visualisation swig_types[282]
#define SWIGTYPE_p_VulkanLayerFlags swig_types[283]
#define SWIGTYPE_p_VulkanLayerRegistrationInfo swig_types[284]
#define SWIGTYPE_p_WindowingData swig_types[285]
#define SWIGTYPE_p_WindowingSystem swig_types[286]
#define SWIGTYPE_p_YcbcrConversion swig_types[287]
#define SWIGTYPE_p_YcbcrRange swig_types[288]
#define SWIGTYPE_p__XDisplay swig_types[289]
#define SWIGTYPE_p_bytebuf swig_types[290]
#define SWIGTYPE_p_char swig_types[291]
#define SWIGTYPE_p_int swig_types[292]
#define SWIGTYPE_p_long swig_types[293]
#define SWIGTYPE_p_p_IRemoteServer swig_types[294]
#define SWIGTYPE_p_rdcarrayT_APIEvent_t swig_types[295]
#define SWIGTYPE_p_rdcarrayT_ActionDescription_t swig_types[296]
#define SWIGTYPE_p_rdcarrayT_BoundVBuffer_t swig_types[297]
#define SWIGTYPE_p_rdcarrayT_BufferDescription_t swig_types[298]
#define SWIGTYPE_p_rdcarrayT_CaptureFileFormat_t swig_types[299]
#define SWIGTYPE_p_rdcarrayT_ColorBlend_t swig_types[300]
#define SWIGTYPE_p_rdcarrayT_ConstantBindStats_t swig_types[301]
#define SWIGTYPE_p_rdcarrayT_ConstantBlock_t swig_types[302]
#define SWIGTYPE_p_rdcarrayT_CounterResult_t swig_types[303]
#define SWIGTYPE_p_rdcarrayT_D3D11Pipe__Layout_t swig_types[304]
#define SWIGTYPE_p_rdcarrayT_D3D11Pipe__StreamOutBind_t swig_types[305]
#define SWIGTYPE_p_rdcarrayT_D3D11Pipe__VertexBuffer_t swig_types[306]
#define SWIGTYPE_p_rdcarrayT_D3D12Pipe__Layout_t swig_types[307]
#define SWIGTYPE_p_rdcarrayT_D3D12Pipe__ResourceData_t swig_types[308]
#define SWIGTYPE_p_rdcarrayT_D3D12Pipe__ResourceState_t swig_types[309]
#define SWIGTYPE_p_rdcarrayT_D3D12Pipe__RootParam_t swig_types[310]
#define SWIGTYPE_p_rdcarrayT_D3D12Pipe__RootTableRange_t swig_types[311]
#define SWIGTYPE_p_rdcarrayT_D3D12Pipe__StaticSampler_t swig_types[312]
#define SWIGTYPE_p_rdcarrayT_D3D12Pipe__StreamOutBind_t swig_types[313]
#define SWIGTYPE_p_rdcarrayT_D3D12Pipe__VertexBuffer_t swig_types[314]
#define SWIGTYPE_p_rdcarrayT_DebugMessage_t swig_types[315]
#define SWIGTYPE_p_rdcarrayT_DebugVariableReference_t swig_types[316]
#define SWIGTYPE_p_rdcarrayT_DescriptorAccess_t swig_types[317]
#define SWIGTYPE_p_rdcarrayT_DescriptorLogicalLocation_t swig_types[318]
#define SWIGTYPE_p_rdcarrayT_DescriptorRange_t swig_types[319]
#define SWIGTYPE_p_rdcarrayT_DescriptorStoreDescription_t swig_types[320]
#define SWIGTYPE_p_rdcarrayT_Descriptor_t swig_types[321]
#define SWIGTYPE_p_rdcarrayT_EnvironmentModification_t swig_types[322]
#define SWIGTYPE_p_rdcarrayT_EventUsage_t swig_types[323]
#define SWIGTYPE_p_rdcarrayT_FloatVector_t swig_types[324]
#define SWIGTYPE_p_rdcarrayT_GLPipe__TextureCompleteness_t swig_types[325]
#define SWIGTYPE_p_rdcarrayT_GLPipe__VertexAttribute_t swig_types[326]
#define SWIGTYPE_p_rdcarrayT_GLPipe__VertexBuffer_t swig_types[327]
#define SWIGTYPE_p_rdcarrayT_GPUCounter_t swig_types[328]
#define SWIGTYPE_p_rdcarrayT_GPUDevice_t swig_types[329]
#define SWIGTYPE_p_rdcarrayT_GraphicsAPI_t swig_types[330]
#define SWIGTYPE_p_rdcarrayT_InstructionSourceInfo_t swig_types[331]
#define SWIGTYPE_p_rdcarrayT_LineColumnInfo_t swig_types[332]
#define SWIGTYPE_p_rdcarrayT_MeshletSize_t swig_types[333]
#define SWIGTYPE_p_rdcarrayT_Offset_t swig_types[334]
#define SWIGTYPE_p_rdcarrayT_PathEntry_t swig_types[335]
#define SWIGTYPE_p_rdcarrayT_PixelModification_t swig_types[336]
#define SWIGTYPE_p_rdcarrayT_ResourceBindStats_t swig_types[337]
#define SWIGTYPE_p_rdcarrayT_ResourceDescription_t swig_types[338]
#define SWIGTYPE_p_rdcarrayT_ResourceId_t swig_types[339]
#define SWIGTYPE_p_rdcarrayT_SamplerBindStats_t swig_types[340]
#define SWIGTYPE_p_rdcarrayT_SamplerDescriptor_t swig_types[341]
#define SWIGTYPE_p_rdcarrayT_Scissor_t swig_types[342]
#define SWIGTYPE_p_rdcarrayT_ShaderChangeStats_t swig_types[343]
#define SWIGTYPE_p_rdcarrayT_ShaderCompileFlag_t swig_types[344]
#define SWIGTYPE_p_rdcarrayT_ShaderConstantType_t swig_types[345]
#define SWIGTYPE_p_rdcarrayT_ShaderConstant_t swig_types[346]
#define SWIGTYPE_p_rdcarrayT_ShaderDebugState_t swig_types[347]
#define SWIGTYPE_p_rdcarrayT_ShaderEncoding_t swig_types[348]
#define SWIGTYPE_p_rdcarrayT_ShaderEntryPoint_t swig_types[349]
#define SWIGTYPE_p_rdcarrayT_ShaderMessage_t swig_types[350]
#define SWIGTYPE_p_rdcarrayT_ShaderResource_t swig_types[351]
#define SWIGTYPE_p_rdcarrayT_ShaderSampler_t swig_types[352]
#define SWIGTYPE_p_rdcarrayT_ShaderSourceFile_t swig_types[353]
#define SWIGTYPE_p_rdcarrayT_ShaderSourcePrefix_t swig_types[354]
#define SWIGTYPE_p_rdcarrayT_ShaderVariableChange_t swig_types[355]
#define SWIGTYPE_p_rdcarrayT_ShaderVariable_t swig_types[356]
#define SWIGTYPE_p_rdcarrayT_SigParameter_t swig_types[357]
#define SWIGTYPE_p_rdcarrayT_SourceVariableMapping_t swig_types[358]
#define SWIGTYPE_p_rdcarrayT_TaskGroupSize_t swig_types[359]
#define SWIGTYPE_p_rdcarrayT_TextureDescription_t swig_types[360]
#define SWIGTYPE_p_rdcarrayT_UsedDescriptor_t swig_types[361]
#define SWIGTYPE_p_rdcarrayT_VKPipe__DescriptorBuffer_t swig_types[362]
#define SWIGTYPE_p_rdcarrayT_VKPipe__DescriptorSet_t swig_types[363]
#define SWIGTYPE_p_rdcarrayT_VKPipe__DynamicOffset_t swig_types[364]
#define SWIGTYPE_p_rdcarrayT_VKPipe__ImageData_t swig_types[365]
#define SWIGTYPE_p_rdcarrayT_VKPipe__ImageLayout_t swig_types[366]
#define SWIGTYPE_p_rdcarrayT_VKPipe__RenderArea_t swig_types[367]
#define SWIGTYPE_p_rdcarrayT_VKPipe__VertexAttribute_t swig_types[368]
#define SWIGTYPE_p_rdcarrayT_VKPipe__VertexBinding_t swig_types[369]
#define SWIGTYPE_p_rdcarrayT_VKPipe__VertexBuffer_t swig_types[370]
#define SWIGTYPE_p_rdcarrayT_VKPipe__ViewportScissor_t swig_types[371]
#define SWIGTYPE_p_rdcarrayT_VKPipe__XFBBuffer_t swig_types[372]
#define SWIGTYPE_p_rdcarrayT_VertexInputAttribute_t swig_types[373]
#define SWIGTYPE_p_rdcarrayT_Viewport_t swig_types[374]
#define SWIGTYPE_p_rdcarrayT_WindowingSystem_t swig_types[375]
#define SWIGTYPE_p_rdcarrayT_float_t swig_types[376]
#define SWIGTYPE_p_rdcarrayT_int_t swig_types[377]
#define SWIGTYPE_p_rdcarrayT_rdcstr_t swig_types[378]
#define SWIGTYPE_p_rdcarrayT_unsigned_int_t swig_types[379]
#define SWIGTYPE_p_rdcarrayT_unsigned_long_t swig_types[380]
#define SWIGTYPE_p_rdcfixedarrayT_ResourceId_4_t swig_types[381]
#define SWIGTYPE_p_rdcfixedarrayT_ResourceId_8_t swig_types[382]
#define SWIGTYPE_p_rdcfixedarrayT_bool_4_t swig_types[383]
#define SWIGTYPE_p_rdcfixedarrayT_bool_8_t swig_types[384]
#define SWIGTYPE_p_rdcfixedarrayT_double_16_t swig_types[385]
#define SWIGTYPE_p_rdcfixedarrayT_float_16_t swig_types[386]
#define SWIGTYPE_p_rdcfixedarrayT_float_2_t swig_types[387]
#define SWIGTYPE_p_rdcfixedarrayT_float_4_t swig_types[388]
#define SWIGTYPE_p_rdcfixedarrayT_int_16_t swig_types[389]
#define SWIGTYPE_p_rdcfixedarrayT_int_4_t swig_types[390]
#define SWIGTYPE_p_rdcfixedarrayT_long_16_t swig_types[391]
#define SWIGTYPE_p_rdcfixedarrayT_rdhalf_16_t swig_types[392]
#define SWIGTYPE_p_rdcfixedarrayT_short_16_t swig_types[393]
#define SWIGTYPE_p_rdcfixedarrayT_signed_char_16_t swig_types[394]
#define SWIGTYPE_p_rdcfixedarrayT_unsigned_char_16_t swig_types[395]
#define SWIGTYPE_p_rdcfixedarrayT_unsigned_int_16_t swig_types[396]
#define SWIGTYPE_p_rdcfixedarrayT_unsigned_int_3_t swig_types[397]
#define SWIGTYPE_p_rdcfixedarrayT_unsigned_int_4_t swig_types[398]
#define SWIGTYPE_p_rdcfixedarrayT_unsigned_long_16_t swig_types[399]
#define SWIGTYPE_p_rdcfixedarrayT_unsigned_long_4_t swig_types[400]
#define SWIGTYPE_p_rdcfixedarrayT_unsigned_short_16_t swig_types[401]
#define SWIGTYPE_p_rdcinflexiblestr swig_types[402]
#define SWIGTYPE_p_rdcpairT_ShadingRateCombiner_ShadingRateCombiner_t swig_types[403]
#define SWIGTYPE_p_rdcpairT_unsigned_int_unsigned_int_t swig_types[404]
#define SWIGTYPE_p_rdcstr swig_types[405]
#define SWIGTYPE_p_short swig_types[406]
#define SWIGTYPE_p_signed_char swig_types[407]
#define SWIGTYPE_p_std__functionT_WindowingData_fbool_rdcarrayT_WindowingSystem_t_const_RF_t swig_types[408]
#define SWIGTYPE_p_std__functionT_bool_fAPIEvent_const_RF_t swig_types[409]
#define SWIGTYPE_p_std__functionT_bool_fActionDescription_const_RF_t swig_types[410]
#define SWIGTYPE_p_std__functionT_bool_fBoundVBuffer_const_RF_t swig_types[411]
#define SWIGTYPE_p_std__functionT_bool_fBufferDescription_const_RF_t swig_types[412]
#define SWIGTYPE_p_std__functionT_bool_fCaptureFileFormat_const_RF_t swig_types[413]
#define SWIGTYPE_p_std__functionT_bool_fColorBlend_const_RF_t swig_types[414]
#define SWIGTYPE_p_std__functionT_bool_fConstantBindStats_const_RF_t swig_types[415]
#define SWIGTYPE_p_std__functionT_bool_fConstantBlock_const_RF_t swig_types[416]
#define SWIGTYPE_p_std__functionT_bool_fCounterResult_const_RF_t swig_types[417]
#define SWIGTYPE_p_std__functionT_bool_fD3D11Pipe__Layout_const_RF_t swig_types[418]
#define SWIGTYPE_p_std__functionT_bool_fD3D11Pipe__StreamOutBind_const_RF_t swig_types[419]
#define SWIGTYPE_p_std__functionT_bool_fD3D11Pipe__VertexBuffer_const_RF_t swig_types[420]
#define SWIGTYPE_p_std__functionT_bool_fD3D12Pipe__Layout_const_RF_t swig_types[421]
#define SWIGTYPE_p_std__functionT_bool_fD3D12Pipe__ResourceData_const_RF_t swig_types[422]
#define SWIGTYPE_p_std__functionT_bool_fD3D12Pipe__ResourceState_const_RF_t swig_types[423]
#define SWIGTYPE_p_std__functionT_bool_fD3D12Pipe__RootParam_const_RF_t swig_types[424]
#define SWIGTYPE_p_std__functionT_bool_fD3D12Pipe__RootTableRange_const_RF_t swig_types[425]
#define SWIGTYPE_p_std__functionT_bool_fD3D12Pipe__StaticSampler_const_RF_t swig_types[426]
#define SWIGTYPE_p_std__functionT_bool_fD3D12Pipe__StreamOutBind_const_RF_t swig_types[427]
#define SWIGTYPE_p_std__functionT_bool_fD3D12Pipe__VertexBuffer_const_RF_t swig_types[428]
#define SWIGTYPE_p_std__functionT_bool_fDebugMessage_const_RF_t swig_types[429]
#define SWIGTYPE_p_std__functionT_bool_fDebugVariableReference_const_RF_t swig_types[430]
#define SWIGTYPE_p_std__functionT_bool_fDescriptorAccess_const_RF_t swig_types[431]
#define SWIGTYPE_p_std__functionT_bool_fDescriptorLogicalLocation_const_RF_t swig_types[432]
#define SWIGTYPE_p_std__functionT_bool_fDescriptorRange_const_RF_t swig_types[433]
#define SWIGTYPE_p_std__functionT_bool_fDescriptorStoreDescription_const_RF_t swig_types[434]
#define SWIGTYPE_p_std__functionT_bool_fDescriptor_const_RF_t swig_types[435]
#define SWIGTYPE_p_std__functionT_bool_fEnvironmentModification_const_RF_t swig_types[436]
#define SWIGTYPE_p_std__functionT_bool_fEventUsage_const_RF_t swig_types[437]
#define SWIGTYPE_p_std__functionT_bool_fF_t swig_types[438]
#define SWIGTYPE_p_std__functionT_bool_fFloatVector_const_RF_t swig_types[439]
#define SWIGTYPE_p_std__functionT_bool_fGLPipe__TextureCompleteness_const_RF_t swig_types[440]
#define SWIGTYPE_p_std__functionT_bool_fGLPipe__VertexAttribute_const_RF_t swig_types[441]
#define SWIGTYPE_p_std__functionT_bool_fGLPipe__VertexBuffer_const_RF_t swig_types[442]
#define SWIGTYPE_p_std__functionT_bool_fGPUCounter_const_RF_t swig_types[443]
#define SWIGTYPE_p_std__functionT_bool_fGPUDevice_const_RF_t swig_types[444]
#define SWIGTYPE_p_std__functionT_bool_fGraphicsAPI_const_RF_t swig_types[445]
#define SWIGTYPE_p_std__functionT_bool_fInstructionSourceInfo_const_RF_t swig_types[446]
#define SWIGTYPE_p_std__functionT_bool_fLineColumnInfo_const_RF_t swig_types[447]
#define SWIGTYPE_p_std__functionT_bool_fMeshletSize_const_RF_t swig_types[448]
#define SWIGTYPE_p_std__functionT_bool_fOffset_const_RF_t swig_types[449]
#define SWIGTYPE_p_std__functionT_bool_fPathEntry_const_RF_t swig_types[450]
#define SWIGTYPE_p_std__functionT_bool_fPixelModification_const_RF_t swig_types[451]
#define SWIGTYPE_p_std__functionT_bool_fResourceBindStats_const_RF_t swig_types[452]
#define SWIGTYPE_p_std__functionT_bool_fResourceDescription_const_RF_t swig_types[453]
#define SWIGTYPE_p_std__functionT_bool_fResourceId_const_RF_t swig_types[454]
#define SWIGTYPE_p_std__functionT_bool_fSamplerBindStats_const_RF_t swig_types[455]
#define SWIGTYPE_p_std__functionT_bool_fSamplerDescriptor_const_RF_t swig_types[456]
#define SWIGTYPE_p_std__functionT_bool_fScissor_const_RF_t swig_types[457]
#define SWIGTYPE_p_std__functionT_bool_fShaderChangeStats_const_RF_t swig_types[458]
#define SWIGTYPE_p_std__functionT_bool_fShaderCompileFlag_const_RF_t swig_types[459]
#define SWIGTYPE_p_std__functionT_bool_fShaderConstantType_const_RF_t swig_types[460]
#define SWIGTYPE_p_std__functionT_bool_fShaderConstant_const_RF_t swig_types[461]
#define SWIGTYPE_p_std__functionT_bool_fShaderDebugState_const_RF_t swig_types[462]
#define SWIGTYPE_p_std__functionT_bool_fShaderEncoding_const_RF_t swig_types[463]
#define SWIGTYPE_p_std__functionT_bool_fShaderEntryPoint_const_RF_t swig_types[464]
#define SWIGTYPE_p_std__functionT_bool_fShaderMessage_const_RF_t swig_types[465]
#define SWIGTYPE_p_std__functionT_bool_fShaderResource_const_RF_t swig_types[466]
#define SWIGTYPE_p_std__functionT_bool_fShaderSampler_const_RF_t swig_types[467]
#define SWIGTYPE_p_std__functionT_bool_fShaderSourceFile_const_RF_t swig_types[468]
#define SWIGTYPE_p_std__functionT_bool_fShaderSourcePrefix_const_RF_t swig_types[469]
#define SWIGTYPE_p_std__functionT_bool_fShaderVariableChange_const_RF_t swig_types[470]
#define SWIGTYPE_p_std__functionT_bool_fShaderVariable_const_RF_t swig_types[471]
#define SWIGTYPE_p_std__functionT_bool_fSigParameter_const_RF_t swig_types[472]
#define SWIGTYPE_p_std__functionT_bool_fSourceVariableMapping_const_RF_t swig_types[473]
#define SWIGTYPE_p_std__functionT_bool_fTaskGroupSize_const_RF_t swig_types[474]
#define SWIGTYPE_p_std__functionT_bool_fTextureDescription_const_RF_t swig_types[475]
#define SWIGTYPE_p_std__functionT_bool_fUsedDescriptor_const_RF_t swig_types[476]
#define SWIGTYPE_p_std__functionT_bool_fVKPipe__DescriptorBuffer_const_RF_t swig_types[477]
#define SWIGTYPE_p_std__functionT_bool_fVKPipe__DescriptorSet_const_RF_t swig_types[478]
#define SWIGTYPE_p_std__functionT_bool_fVKPipe__DynamicOffset_const_RF_t swig_types[479]
#define SWIGTYPE_p_std__functionT_bool_fVKPipe__ImageData_const_RF_t swig_types[480]
#define SWIGTYPE_p_std__functionT_bool_fVKPipe__ImageLayout_const_RF_t swig_types[481]
#define SWIGTYPE_p_std__functionT_bool_fVKPipe__RenderArea_const_RF_t swig_types[482]
#define SWIGTYPE_p_std__functionT_bool_fVKPipe__VertexAttribute_const_RF_t swig_types[483]
#define SWIGTYPE_p_std__functionT_bool_fVKPipe__VertexBinding_const_RF_t swig_types[484]
#define SWIGTYPE_p_std__functionT_bool_fVKPipe__VertexBuffer_const_RF_t swig_types[485]
#define SWIGTYPE_p_std__functionT_bool_fVKPipe__ViewportScissor_const_RF_t swig_types[486]
#define SWIGTYPE_p_std__functionT_bool_fVKPipe__XFBBuffer_const_RF_t swig_types[487]
#define SWIGTYPE_p_std__functionT_bool_fVertexInputAttribute_const_RF_t swig_types[488]
#define SWIGTYPE_p_std__functionT_bool_fViewport_const_RF_t swig_types[489]
#define SWIGTYPE_p_std__functionT_bool_fWindowingSystem_const_RF_t swig_types[490]
#define SWIGTYPE_p_std__functionT_bool_ffloat_const_RF_t swig_types[491]
#define SWIGTYPE_p_std__functionT_bool_fint_const_RF_t swig_types[492]
#define SWIGTYPE_p_std__functionT_bool_frdcstr_const_RF_t swig_types[493]
#define SWIGTYPE_p_std__functionT_bool_funsigned_int_const_RF_t swig_types[494]
#define SWIGTYPE_p_std__functionT_bool_funsigned_long_const_RF_t swig_types[495]
#define SWIGTYPE_p_std__functionT_void_ffloatF_t swig_types[496]
#define SWIGTYPE_p_unsigned_char swig_types[497]
#define SWIGTYPE_p_unsigned_int swig_types[498]
#define SWIGTYPE_p_unsigned_long swig_types[499]
#define SWIGTYPE_p_unsigned_short swig_types[500]
#define SWIGTYPE_p_value_type swig_types[501]
#define SWIGTYPE_p_wl_display swig_types[502]
#define SWIGTYPE_p_wl_surface swig_types[503]
#define SWIGTYPE_p_xcb_connection_t swig_types[504]
static swig_type_info *swig_types[506];
static swig_module_info swig_module = {swig_types, 505, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

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

#if (PY_VERSION_HEX <= 0x02000000)
# if !defined(SWIG_PYTHON_CLASSIC)
#  error "This python version requires swig to be run with the '-classic' option"
# endif
#endif
#if (PY_VERSION_HEX <= 0x02020000)
# error "This python version requires swig to be run with the '-nomodern' option"
#endif
#if (PY_VERSION_HEX <= 0x02020000)
# error "This python version requires swig to be run with the '-nomodernargs' option"
#endif
#ifndef METH_O
# error "This python version requires swig to be run with the '-nofastunpack' option"
#endif
#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery

/*-----------------------------------------------
              @(target):= renderdoc.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit_renderdoc

#else
#  define SWIG_init    initrenderdoc

#endif
#define SWIG_name    "renderdoc"

#define SWIGVERSION 0x030012 
#define SWIG_VERSION SWIGVERSION


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


#include <stdexcept>


namespace swig {
  class SwigPtr_PyObject {
  protected:
    PyObject *_obj;

  public:
    SwigPtr_PyObject() :_obj(0)
    {
    }

    SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XINCREF(_obj);      
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    {
      if (initial_ref) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        Py_XINCREF(_obj);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XINCREF(item._obj);
      Py_XDECREF(_obj);
      _obj = item._obj;
      SWIG_PYTHON_THREAD_END_BLOCK;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XDECREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    operator PyObject *() const
    {
      return _obj;
    }

    PyObject *operator->() const
    {
      return _obj;
    }
  };
}


namespace swig {
  struct SwigVar_PyObject : SwigPtr_PyObject {
    SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
    
    SwigVar_PyObject & operator = (PyObject* obj)
    {
      Py_XDECREF(_obj);
      _obj = obj;
      return *this;      
    }
  };
}


#include <stddef.h>


#include "3rdparty/pythoncapi_compat.h"


  #include "datetime.h"


  #include "renderdoc_replay.h"

  static char convert_error[1024] = {};
  
  #include "Code/pyrenderdoc/pyconversion.h"

  // declare the basic building blocks as stringize types
  DECLARE_STRINGISE_TYPE(int8_t);
  DECLARE_STRINGISE_TYPE(uint8_t);
  DECLARE_STRINGISE_TYPE(int16_t);
  DECLARE_STRINGISE_TYPE(uint16_t);
  DECLARE_STRINGISE_TYPE(int32_t);
  DECLARE_STRINGISE_TYPE(uint32_t);
  DECLARE_STRINGISE_TYPE(int64_t);
  DECLARE_STRINGISE_TYPE(uint64_t);
  DECLARE_STRINGISE_TYPE(float);
  DECLARE_STRINGISE_TYPE(double);
  DECLARE_STRINGISE_TYPE(rdcstr);



// hacky macro to check if two variables are the same by looking at their length & second letter.
// Used to identify if we're dealing with 'self' in a typemap or not
#define STR_EQ(a, b) (sizeof(#a) == sizeof(#b) && (#a[1] == #b[1]))


template<typename innerType>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<innerType> *);


template<typename innerType, size_t N>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<innerType, N> *);


#include <stdint.h>		// Use the C99 official header


#define SWIGWORDSIZE64
#ifndef LONG_MAX
#include <limits.h>
#endif
#if (__WORDSIZE == 32) || (LONG_MAX == INT_MAX)
# error "SWIG wrapped code invalid in 32 bit architecture, regenerate code using -DSWIGWORDSIZE32"
#endif


#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
#   define LLONG_MAX __LONG_LONG_MAX__
#   define LLONG_MIN (-LLONG_MAX - 1LL)
#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif


SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
  int res = SWIG_TypeError;
  if (PyFloat_Check(obj)) {
    if (val) *val = PyFloat_AsDouble(obj);
    return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
  } else if (PyInt_Check(obj)) {
    if (val) *val = (double) PyInt_AsLong(obj);
    return SWIG_OK;
#endif
  } else if (PyLong_Check(obj)) {
    double v = PyLong_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    double d = PyFloat_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = d;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      long v = PyLong_AsLong(obj);
      if (!PyErr_Occurred()) {
	if (val) *val = v;
	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
      } else {
	PyErr_Clear();
      }
    }
  }
#endif
  return res;
}


#include <float.h>


#include <math.h>


SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
  double x = *d;
  if ((min <= x && x <= max)) {
   double fx = floor(x);
   double cx = ceil(x);
   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
   if ((errno == EDOM) || (errno == ERANGE)) {
     errno = 0;
   } else {
     double summ, reps, diff;
     if (rd < x) {
       diff = x - rd;
     } else if (rd > x) {
       diff = rd - x;
     } else {
       return 1;
     }
     summ = rd + x;
     reps = diff/summ;
     if (reps < 8*DBL_EPSILON) {
       *d = rd;
       return 1;
     }
   }
  }
  return 0;
}


SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else
#endif
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    long v = PyInt_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


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


SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    long v = PyInt_AsLong(obj);
    if (v >= 0) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      return SWIG_OverflowError;
    }
  } else
#endif
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
	if (val) *val = (unsigned long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned int >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject*
  SWIG_From_unsigned_SS_int  (unsigned int value)
{
  return PyInt_FromSize_t((size_t) value);
}


SWIGINTERN int
SWIG_AsVal_bool (PyObject *obj, bool *val)
{
  int r;
  if (!PyBool_Check(obj))
    return SWIG_ERROR;
  r = PyObject_IsTrue(obj);
  if (r == -1)
    return SWIG_ERROR;
  if (val) *val = r ? true : false;
  return SWIG_OK;
}


/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
#ifndef SWIG_isfinite
/* isfinite() is a macro for C99 */
# if defined(isfinite)
#  define SWIG_isfinite(X) (isfinite(X))
# elif defined __cplusplus && __cplusplus >= 201103L
/* Use a template so that this works whether isfinite() is std::isfinite() or
 * in the global namespace.  The reality seems to vary between compiler
 * versions.
 *
 * Make sure namespace std exists to avoid compiler warnings.
 *
 * extern "C++" is required as this fragment can end up inside an extern "C" { } block
 */
namespace std { }
extern "C++" template<typename T>
inline int SWIG_isfinite_func(T x) {
  using namespace std;
  return isfinite(x);
}
#  define SWIG_isfinite(X) (SWIG_isfinite_func(X))
# elif defined(_MSC_VER)
#  define SWIG_isfinite(X) (_finite(X))
# elif defined(__sun) && defined(__SVR4)
#  include <ieeefp.h>
#  define SWIG_isfinite(X) (finite(X))
# endif
#endif


/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
#ifdef SWIG_isfinite
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
#else
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
#endif


SWIGINTERN int
SWIG_AsVal_float (PyObject * obj, float *val)
{
  double v;
  int res = SWIG_AsVal_double (obj, &v);
  if (SWIG_IsOK(res)) {
    if (SWIG_Float_Overflow_Check(v)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< float >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject*
  SWIG_From_bool  (bool value)
{
  return PyBool_FromLong(value ? 1 : 0);
}


SWIGINTERNINLINE PyObject*
  SWIG_From_int  (int value)
{
  return PyInt_FromLong((long) value);
}


  #define SWIG_From_long   PyInt_FromLong 


SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
}


  #define SWIG_From_double   PyFloat_FromDouble 


SWIGINTERN int
SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > USHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned short >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject *
SWIG_From_float  (float value)
{    
  return SWIG_From_double  (value);
}


SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_short  (unsigned short value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


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


SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > INT_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
	SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    } else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
      return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#else
#if PY_VERSION_HEX >= 0x03010000
      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
#else
      return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#endif
#endif
#else
      return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


SWIGINTERNINLINE PyObject * 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}

SWIGINTERN PyObject *ResourceId___lt__(ResourceId *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ResourceId *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ResourceId, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ResourceId *)resptr;

    result = (*self < *id);
  }

  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ResourceId___eq__(ResourceId *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ResourceId *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ResourceId, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ResourceId *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ResourceId___ne__(ResourceId *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  ResourceId *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ResourceId, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ResourceId *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}

SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
  if (PyBytes_Check(obj))
#else
  if (PyUnicode_Check(obj))
#endif
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    if (!alloc && cptr) {
        /* We can't allow converting without allocation, since the internal
           representation of string in Python 3 is UCS-2/UCS-4 but we require
           a UTF-8 representation.
           TODO(bhy) More detailed explanation */
        return SWIG_RuntimeError;
    }
    obj = PyUnicode_AsUTF8String(obj);
    if(alloc) *alloc = SWIG_NEWOBJ;
#endif
    PyBytes_AsStringAndSize(obj, &cstr, &len);
#else
    PyString_AsStringAndSize(obj, &cstr, &len);
#endif
    if (cptr) {
      if (alloc) {
	/* 
	   In python the user should not be able to modify the inner
	   string representation. To warranty that, if you define
	   SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
	   buffer is always returned.

	   The default behavior is just to return the pointer value,
	   so, be careful.
	*/ 
#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
	if (*alloc != SWIG_OLDOBJ) 
#else
	if (*alloc == SWIG_NEWOBJ) 
#endif
	{
	  *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
	  *alloc = SWIG_NEWOBJ;
	} else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      } else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
	*cptr = PyBytes_AsString(obj);
#else
	assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
	*cptr = SWIG_Python_str_AsChar(obj);
#endif
      }
    }
    if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    Py_XDECREF(obj);
#endif
    return SWIG_OK;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        }
        if (psize) *psize = len + 1;

        Py_XDECREF(obj);
        return SWIG_OK;
      } else {
        Py_XDECREF(obj);
      }
    }
#endif
#endif

    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *) vptr;
	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{ 
  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
  if (SWIG_IsOK(res)) {
    /* special case of single char conversion when we don't need space for NUL */
    if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    if (csize <= size) {
      if (val) {
	if (csize) memcpy(val, cptr, csize*sizeof(char));
	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
      }
      if (alloc == SWIG_NEWOBJ) {
	delete[] cptr;
	res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) delete[] cptr;
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_char (PyObject * obj, char *val)
{    
  int res = SWIG_AsCharArray(obj, val, 1);
  if (!SWIG_IsOK(res)) {
    long v;
    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    if (SWIG_IsOK(res)) {
      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
	if (val) *val = static_cast< char >(v);
      } else {
	res = SWIG_OverflowError;
      }
    }
  }
  return res;
}


SWIGINTERNINLINE PyObject *
SWIG_From_char  (char c) 
{ 
  return SWIG_FromCharPtrAndSize(&c,1);
}

SWIGINTERN PyObject *StructuredObjectList_append(StructuredObjectList *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *StructuredObjectList_clear(StructuredObjectList *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *StructuredObjectList_insert(StructuredObjectList *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *StructuredObjectList_pop(StructuredObjectList *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *StructuredObjectList_sort(StructuredObjectList *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *StructuredObjectList_copy(StructuredObjectList *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *StructuredObjectList_reverse(StructuredObjectList *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *StructuredObjectList_index(StructuredObjectList *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *StructuredObjectList_count(StructuredObjectList *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *StructuredObjectList_extend(StructuredObjectList *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *StructuredObjectList_remove(StructuredObjectList *self,PyObject *item){
      return array_removeOne(self, item);
    }

#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
#  define SWIG_LONG_LONG_AVAILABLE
#endif


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
      if (val) *val = (unsigned long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    unsigned long v = 0;
    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    unsigned long long v = 0;
    res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  }
#endif
  return res;
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif


SWIGINTERNINLINE PyObject *
SWIG_From_size_t  (size_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
  }
#endif
}

SWIGINTERN PyObject *SDObject_AsInt(SDObject *self){
    if(self->type.basetype == SDBasic::UnsignedInteger)
      return ConvertToPy(self->data.basic.u);
    else
      return ConvertToPy(self->data.basic.i);
  }
SWIGINTERN PyObject *SDObject_AsFloat(SDObject *self){ return ConvertToPy(self->data.basic.d); }
SWIGINTERN PyObject *SDObject_AsString(SDObject *self){ return ConvertToPy(self->data.str); }
SWIGINTERN PyObject *StructuredChunkList_append(StructuredChunkList *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *StructuredChunkList_clear(StructuredChunkList *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *StructuredChunkList_insert(StructuredChunkList *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *StructuredChunkList_pop(StructuredChunkList *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *StructuredChunkList_sort(StructuredChunkList *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *StructuredChunkList_copy(StructuredChunkList *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *StructuredChunkList_reverse(StructuredChunkList *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *StructuredChunkList_index(StructuredChunkList *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *StructuredChunkList_count(StructuredChunkList *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *StructuredChunkList_extend(StructuredChunkList *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *StructuredChunkList_remove(StructuredChunkList *self,PyObject *item){
      return array_removeOne(self, item);
    }
SWIGINTERN PyObject *StructuredBufferList_append(StructuredBufferList *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *StructuredBufferList_clear(StructuredBufferList *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *StructuredBufferList_insert(StructuredBufferList *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *StructuredBufferList_pop(StructuredBufferList *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *StructuredBufferList_sort(StructuredBufferList *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *StructuredBufferList_copy(StructuredBufferList *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *StructuredBufferList_reverse(StructuredBufferList *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *StructuredBufferList_index(StructuredBufferList *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *StructuredBufferList_count(StructuredBufferList *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *StructuredBufferList_extend(StructuredBufferList *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *StructuredBufferList_remove(StructuredBufferList *self,PyObject *item){
      return array_removeOne(self, item);
    }
SWIGINTERN PyObject *EnvironmentModification___eq__(EnvironmentModification *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  EnvironmentModification *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_EnvironmentModification, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (EnvironmentModification *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *EnvironmentModification___ne__(EnvironmentModification *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  EnvironmentModification *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_EnvironmentModification, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (EnvironmentModification *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *CaptureFileFormat___eq__(CaptureFileFormat *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  CaptureFileFormat *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_CaptureFileFormat, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (CaptureFileFormat *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *CaptureFileFormat___ne__(CaptureFileFormat *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  CaptureFileFormat *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_CaptureFileFormat, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (CaptureFileFormat *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *Viewport___eq__(Viewport *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  Viewport *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_Viewport, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (Viewport *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *Viewport___ne__(Viewport *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  Viewport *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_Viewport, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (Viewport *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *Scissor___eq__(Scissor *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  Scissor *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_Scissor, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (Scissor *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *Scissor___ne__(Scissor *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  Scissor *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_Scissor, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (Scissor *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}

SWIGINTERN int
SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UCHAR_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned char >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_char  (unsigned char value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}

SWIGINTERN PyObject *ColorBlend___eq__(ColorBlend *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ColorBlend *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ColorBlend, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ColorBlend *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ColorBlend___ne__(ColorBlend *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  ColorBlend *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ColorBlend, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ColorBlend *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *BoundVBuffer___eq__(BoundVBuffer *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  BoundVBuffer *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_BoundVBuffer, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (BoundVBuffer *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *BoundVBuffer___ne__(BoundVBuffer *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  BoundVBuffer *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_BoundVBuffer, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (BoundVBuffer *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *VertexInputAttribute___eq__(VertexInputAttribute *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  VertexInputAttribute *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_VertexInputAttribute, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (VertexInputAttribute *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *VertexInputAttribute___ne__(VertexInputAttribute *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  VertexInputAttribute *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_VertexInputAttribute, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (VertexInputAttribute *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *PathEntry___eq__(PathEntry *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  PathEntry *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_PathEntry, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (PathEntry *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *PathEntry___ne__(PathEntry *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  PathEntry *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_PathEntry, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (PathEntry *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ResourceDescription___eq__(ResourceDescription *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ResourceDescription *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ResourceDescription, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ResourceDescription *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ResourceDescription___ne__(ResourceDescription *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  ResourceDescription *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ResourceDescription, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ResourceDescription *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *BufferDescription___eq__(BufferDescription *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  BufferDescription *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_BufferDescription, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (BufferDescription *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *BufferDescription___ne__(BufferDescription *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  BufferDescription *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_BufferDescription, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (BufferDescription *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *TextureDescription___eq__(TextureDescription *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  TextureDescription *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_TextureDescription, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (TextureDescription *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *TextureDescription___ne__(TextureDescription *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  TextureDescription *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_TextureDescription, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (TextureDescription *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *APIEvent___eq__(APIEvent *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  APIEvent *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_APIEvent, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (APIEvent *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *APIEvent___ne__(APIEvent *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  APIEvent *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_APIEvent, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (APIEvent *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *DebugMessage___eq__(DebugMessage *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  DebugMessage *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_DebugMessage, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (DebugMessage *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *DebugMessage___ne__(DebugMessage *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  DebugMessage *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_DebugMessage, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (DebugMessage *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *EventUsage___eq__(EventUsage *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  EventUsage *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_EventUsage, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (EventUsage *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *EventUsage___ne__(EventUsage *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  EventUsage *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_EventUsage, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (EventUsage *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ActionDescription___eq__(ActionDescription *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ActionDescription *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ActionDescription, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ActionDescription *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ActionDescription___ne__(ActionDescription *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  ActionDescription *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ActionDescription, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ActionDescription *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}

SWIGINTERN size_t
SWIG_strnlen(const char* s, size_t maxlen)
{
  const char *p;
  for (p = s; maxlen-- && *p; p++)
    ;
  return p - s;
}

SWIGINTERN PyObject *CounterResult___eq__(CounterResult *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  CounterResult *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_CounterResult, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (CounterResult *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *CounterResult___ne__(CounterResult *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  CounterResult *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_CounterResult, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (CounterResult *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *PixelModification___eq__(PixelModification *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  PixelModification *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_PixelModification, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (PixelModification *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *PixelModification___ne__(PixelModification *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  PixelModification *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_PixelModification, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (PixelModification *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderVariable___eq__(ShaderVariable *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ShaderVariable *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderVariable, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderVariable *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderVariable___ne__(ShaderVariable *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  ShaderVariable *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderVariable, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderVariable *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *DebugVariableReference___eq__(DebugVariableReference *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  DebugVariableReference *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_DebugVariableReference, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (DebugVariableReference *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *DebugVariableReference___ne__(DebugVariableReference *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  DebugVariableReference *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_DebugVariableReference, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (DebugVariableReference *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *SourceVariableMapping___eq__(SourceVariableMapping *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  SourceVariableMapping *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_SourceVariableMapping, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (SourceVariableMapping *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *SourceVariableMapping___ne__(SourceVariableMapping *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  SourceVariableMapping *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_SourceVariableMapping, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (SourceVariableMapping *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *LineColumnInfo___eq__(LineColumnInfo *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  LineColumnInfo *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_LineColumnInfo, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (LineColumnInfo *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *LineColumnInfo___ne__(LineColumnInfo *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  LineColumnInfo *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_LineColumnInfo, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (LineColumnInfo *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderDebugState___eq__(ShaderDebugState *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ShaderDebugState *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderDebugState, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderDebugState *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderDebugState___ne__(ShaderDebugState *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  ShaderDebugState *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderDebugState, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderDebugState *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *SigParameter___eq__(SigParameter *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  SigParameter *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_SigParameter, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (SigParameter *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *SigParameter___ne__(SigParameter *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  SigParameter *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_SigParameter, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (SigParameter *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderConstant___eq__(ShaderConstant *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ShaderConstant *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderConstant, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderConstant *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderConstant___ne__(ShaderConstant *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  ShaderConstant *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderConstant, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderConstant *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ConstantBlock___eq__(ConstantBlock *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ConstantBlock *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ConstantBlock, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ConstantBlock *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ConstantBlock___ne__(ConstantBlock *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  ConstantBlock *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ConstantBlock, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ConstantBlock *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderSampler___eq__(ShaderSampler *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ShaderSampler *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderSampler, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderSampler *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderSampler___ne__(ShaderSampler *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  ShaderSampler *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderSampler, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderSampler *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderResource___eq__(ShaderResource *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ShaderResource *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderResource, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderResource *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderResource___ne__(ShaderResource *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  ShaderResource *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderResource, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderResource *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderEntryPoint___eq__(ShaderEntryPoint *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ShaderEntryPoint *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderEntryPoint, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderEntryPoint *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderEntryPoint___ne__(ShaderEntryPoint *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  ShaderEntryPoint *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderEntryPoint, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderEntryPoint *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderCompileFlag___eq__(ShaderCompileFlag *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ShaderCompileFlag *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderCompileFlag, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderCompileFlag *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderCompileFlag___ne__(ShaderCompileFlag *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  ShaderCompileFlag *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderCompileFlag, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderCompileFlag *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderSourceFile___eq__(ShaderSourceFile *self,PyObject *other){
  bool result = false;
  void *resptr = NULL;
  ShaderSourceFile *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderSourceFile, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderSourceFile *)resptr;

    result = (*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}
SWIGINTERN PyObject *ShaderSourceFile___ne__(ShaderSourceFile *self,PyObject *other){
  bool result = true;
  void *resptr = NULL;
  ShaderSourceFile *id = NULL;

  if(other && !Py_IsNone(other))
  {
    int res = SWIG_ConvertPtr(other, &resptr, SWIGTYPE_p_ShaderSourceFile, 0);
    if (!SWIG_IsOK(res)) {
      goto fail;
    }

    id = (ShaderSourceFile *)resptr;

    result = !(*self == *id);
  }
  
  return PyBool_FromLong(result ? 1 : 0);
fail:
  return NULL;
}

  
extern "C" PyObject *RENDERDOC_DumpObject(PyObject *obj);




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<float, 2> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<float, 4> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<uint32_t, 3> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<uint32_t, 4> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<uint64_t, 4> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<int32_t, 4> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<ResourceId, 4> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<ResourceId, 8> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<bool, 4> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<bool, 8> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<float, 16> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<rdhalf, 16> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<int32_t, 16> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<uint32_t, 16> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<double, 16> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<uint64_t, 16> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<int64_t, 16> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<uint16_t, 16> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<int16_t, 16> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<uint8_t, 16> *)
{
}




template<>
void  add_your_use_of_rdcfixedarray_to_swig_interface (rdcfixedarray<int8_t, 16> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_int_Sg__append(rdcarray< int > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_int_Sg__clear(rdcarray< int > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_int_Sg__insert(rdcarray< int > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_int_Sg__pop(rdcarray< int > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_int_Sg__sort(rdcarray< int > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_int_Sg__copy(rdcarray< int > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_int_Sg__reverse(rdcarray< int > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_int_Sg__index(rdcarray< int > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_int_Sg__count(rdcarray< int > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_int_Sg__extend(rdcarray< int > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_int_Sg__remove(rdcarray< int > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<int> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_float_Sg__append(rdcarray< float > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_float_Sg__clear(rdcarray< float > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_float_Sg__insert(rdcarray< float > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_float_Sg__pop(rdcarray< float > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_float_Sg__sort(rdcarray< float > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_float_Sg__copy(rdcarray< float > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_float_Sg__reverse(rdcarray< float > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_float_Sg__index(rdcarray< float > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_float_Sg__count(rdcarray< float > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_float_Sg__extend(rdcarray< float > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_float_Sg__remove(rdcarray< float > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<float> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_uint32_t_Sg__append(rdcarray< uint32_t > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint32_t_Sg__clear(rdcarray< uint32_t > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint32_t_Sg__insert(rdcarray< uint32_t > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint32_t_Sg__pop(rdcarray< uint32_t > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint32_t_Sg__sort(rdcarray< uint32_t > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint32_t_Sg__copy(rdcarray< uint32_t > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint32_t_Sg__reverse(rdcarray< uint32_t > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint32_t_Sg__index(rdcarray< uint32_t > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint32_t_Sg__count(rdcarray< uint32_t > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint32_t_Sg__extend(rdcarray< uint32_t > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint32_t_Sg__remove(rdcarray< uint32_t > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<uint32_t> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_uint64_t_Sg__append(rdcarray< uint64_t > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint64_t_Sg__clear(rdcarray< uint64_t > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint64_t_Sg__insert(rdcarray< uint64_t > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint64_t_Sg__pop(rdcarray< uint64_t > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint64_t_Sg__sort(rdcarray< uint64_t > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint64_t_Sg__copy(rdcarray< uint64_t > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint64_t_Sg__reverse(rdcarray< uint64_t > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint64_t_Sg__index(rdcarray< uint64_t > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint64_t_Sg__count(rdcarray< uint64_t > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint64_t_Sg__extend(rdcarray< uint64_t > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_uint64_t_Sg__remove(rdcarray< uint64_t > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<uint64_t> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_rdcstr_Sg__append(rdcarray< rdcstr > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_rdcstr_Sg__clear(rdcarray< rdcstr > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_rdcstr_Sg__insert(rdcarray< rdcstr > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_rdcstr_Sg__pop(rdcarray< rdcstr > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_rdcstr_Sg__sort(rdcarray< rdcstr > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_rdcstr_Sg__copy(rdcarray< rdcstr > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_rdcstr_Sg__reverse(rdcarray< rdcstr > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_rdcstr_Sg__index(rdcarray< rdcstr > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_rdcstr_Sg__count(rdcarray< rdcstr > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_rdcstr_Sg__extend(rdcarray< rdcstr > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_rdcstr_Sg__remove(rdcarray< rdcstr > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<rdcstr> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_WindowingSystem_Sg__append(rdcarray< WindowingSystem > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_WindowingSystem_Sg__clear(rdcarray< WindowingSystem > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_WindowingSystem_Sg__insert(rdcarray< WindowingSystem > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_WindowingSystem_Sg__pop(rdcarray< WindowingSystem > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_WindowingSystem_Sg__sort(rdcarray< WindowingSystem > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_WindowingSystem_Sg__copy(rdcarray< WindowingSystem > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_WindowingSystem_Sg__reverse(rdcarray< WindowingSystem > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_WindowingSystem_Sg__index(rdcarray< WindowingSystem > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_WindowingSystem_Sg__count(rdcarray< WindowingSystem > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_WindowingSystem_Sg__extend(rdcarray< WindowingSystem > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_WindowingSystem_Sg__remove(rdcarray< WindowingSystem > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<WindowingSystem> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ActionDescription_Sg__append(rdcarray< ActionDescription > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ActionDescription_Sg__clear(rdcarray< ActionDescription > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ActionDescription_Sg__insert(rdcarray< ActionDescription > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ActionDescription_Sg__pop(rdcarray< ActionDescription > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ActionDescription_Sg__sort(rdcarray< ActionDescription > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ActionDescription_Sg__copy(rdcarray< ActionDescription > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ActionDescription_Sg__reverse(rdcarray< ActionDescription > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ActionDescription_Sg__index(rdcarray< ActionDescription > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ActionDescription_Sg__count(rdcarray< ActionDescription > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ActionDescription_Sg__extend(rdcarray< ActionDescription > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ActionDescription_Sg__remove(rdcarray< ActionDescription > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ActionDescription> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_GPUCounter_Sg__append(rdcarray< GPUCounter > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUCounter_Sg__clear(rdcarray< GPUCounter > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUCounter_Sg__insert(rdcarray< GPUCounter > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUCounter_Sg__pop(rdcarray< GPUCounter > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUCounter_Sg__sort(rdcarray< GPUCounter > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUCounter_Sg__copy(rdcarray< GPUCounter > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUCounter_Sg__reverse(rdcarray< GPUCounter > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUCounter_Sg__index(rdcarray< GPUCounter > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUCounter_Sg__count(rdcarray< GPUCounter > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUCounter_Sg__extend(rdcarray< GPUCounter > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUCounter_Sg__remove(rdcarray< GPUCounter > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<GPUCounter> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_CounterResult_Sg__append(rdcarray< CounterResult > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_CounterResult_Sg__clear(rdcarray< CounterResult > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_CounterResult_Sg__insert(rdcarray< CounterResult > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_CounterResult_Sg__pop(rdcarray< CounterResult > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_CounterResult_Sg__sort(rdcarray< CounterResult > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_CounterResult_Sg__copy(rdcarray< CounterResult > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_CounterResult_Sg__reverse(rdcarray< CounterResult > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_CounterResult_Sg__index(rdcarray< CounterResult > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_CounterResult_Sg__count(rdcarray< CounterResult > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_CounterResult_Sg__extend(rdcarray< CounterResult > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_CounterResult_Sg__remove(rdcarray< CounterResult > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<CounterResult> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_APIEvent_Sg__append(rdcarray< APIEvent > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_APIEvent_Sg__clear(rdcarray< APIEvent > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_APIEvent_Sg__insert(rdcarray< APIEvent > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_APIEvent_Sg__pop(rdcarray< APIEvent > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_APIEvent_Sg__sort(rdcarray< APIEvent > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_APIEvent_Sg__copy(rdcarray< APIEvent > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_APIEvent_Sg__reverse(rdcarray< APIEvent > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_APIEvent_Sg__index(rdcarray< APIEvent > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_APIEvent_Sg__count(rdcarray< APIEvent > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_APIEvent_Sg__extend(rdcarray< APIEvent > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_APIEvent_Sg__remove(rdcarray< APIEvent > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<APIEvent> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_DescriptorStoreDescription_Sg__append(rdcarray< DescriptorStoreDescription > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorStoreDescription_Sg__clear(rdcarray< DescriptorStoreDescription > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorStoreDescription_Sg__insert(rdcarray< DescriptorStoreDescription > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorStoreDescription_Sg__pop(rdcarray< DescriptorStoreDescription > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorStoreDescription_Sg__sort(rdcarray< DescriptorStoreDescription > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorStoreDescription_Sg__copy(rdcarray< DescriptorStoreDescription > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorStoreDescription_Sg__reverse(rdcarray< DescriptorStoreDescription > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorStoreDescription_Sg__index(rdcarray< DescriptorStoreDescription > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorStoreDescription_Sg__count(rdcarray< DescriptorStoreDescription > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorStoreDescription_Sg__extend(rdcarray< DescriptorStoreDescription > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorStoreDescription_Sg__remove(rdcarray< DescriptorStoreDescription > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<DescriptorStoreDescription> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_BufferDescription_Sg__append(rdcarray< BufferDescription > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_BufferDescription_Sg__clear(rdcarray< BufferDescription > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_BufferDescription_Sg__insert(rdcarray< BufferDescription > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_BufferDescription_Sg__pop(rdcarray< BufferDescription > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_BufferDescription_Sg__sort(rdcarray< BufferDescription > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_BufferDescription_Sg__copy(rdcarray< BufferDescription > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_BufferDescription_Sg__reverse(rdcarray< BufferDescription > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_BufferDescription_Sg__index(rdcarray< BufferDescription > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_BufferDescription_Sg__count(rdcarray< BufferDescription > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_BufferDescription_Sg__extend(rdcarray< BufferDescription > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_BufferDescription_Sg__remove(rdcarray< BufferDescription > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<BufferDescription> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_CaptureFileFormat_Sg__append(rdcarray< CaptureFileFormat > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_CaptureFileFormat_Sg__clear(rdcarray< CaptureFileFormat > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_CaptureFileFormat_Sg__insert(rdcarray< CaptureFileFormat > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_CaptureFileFormat_Sg__pop(rdcarray< CaptureFileFormat > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_CaptureFileFormat_Sg__sort(rdcarray< CaptureFileFormat > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_CaptureFileFormat_Sg__copy(rdcarray< CaptureFileFormat > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_CaptureFileFormat_Sg__reverse(rdcarray< CaptureFileFormat > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_CaptureFileFormat_Sg__index(rdcarray< CaptureFileFormat > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_CaptureFileFormat_Sg__count(rdcarray< CaptureFileFormat > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_CaptureFileFormat_Sg__extend(rdcarray< CaptureFileFormat > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_CaptureFileFormat_Sg__remove(rdcarray< CaptureFileFormat > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<CaptureFileFormat> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ConstantBlock_Sg__append(rdcarray< ConstantBlock > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBlock_Sg__clear(rdcarray< ConstantBlock > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBlock_Sg__insert(rdcarray< ConstantBlock > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBlock_Sg__pop(rdcarray< ConstantBlock > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBlock_Sg__sort(rdcarray< ConstantBlock > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBlock_Sg__copy(rdcarray< ConstantBlock > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBlock_Sg__reverse(rdcarray< ConstantBlock > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBlock_Sg__index(rdcarray< ConstantBlock > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBlock_Sg__count(rdcarray< ConstantBlock > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBlock_Sg__extend(rdcarray< ConstantBlock > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBlock_Sg__remove(rdcarray< ConstantBlock > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ConstantBlock> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_DebugMessage_Sg__append(rdcarray< DebugMessage > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugMessage_Sg__clear(rdcarray< DebugMessage > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugMessage_Sg__insert(rdcarray< DebugMessage > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugMessage_Sg__pop(rdcarray< DebugMessage > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugMessage_Sg__sort(rdcarray< DebugMessage > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugMessage_Sg__copy(rdcarray< DebugMessage > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugMessage_Sg__reverse(rdcarray< DebugMessage > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugMessage_Sg__index(rdcarray< DebugMessage > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugMessage_Sg__count(rdcarray< DebugMessage > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugMessage_Sg__extend(rdcarray< DebugMessage > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugMessage_Sg__remove(rdcarray< DebugMessage > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<DebugMessage> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_EnvironmentModification_Sg__append(rdcarray< EnvironmentModification > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_EnvironmentModification_Sg__clear(rdcarray< EnvironmentModification > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_EnvironmentModification_Sg__insert(rdcarray< EnvironmentModification > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_EnvironmentModification_Sg__pop(rdcarray< EnvironmentModification > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_EnvironmentModification_Sg__sort(rdcarray< EnvironmentModification > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_EnvironmentModification_Sg__copy(rdcarray< EnvironmentModification > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_EnvironmentModification_Sg__reverse(rdcarray< EnvironmentModification > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_EnvironmentModification_Sg__index(rdcarray< EnvironmentModification > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_EnvironmentModification_Sg__count(rdcarray< EnvironmentModification > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_EnvironmentModification_Sg__extend(rdcarray< EnvironmentModification > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_EnvironmentModification_Sg__remove(rdcarray< EnvironmentModification > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<EnvironmentModification> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_EventUsage_Sg__append(rdcarray< EventUsage > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_EventUsage_Sg__clear(rdcarray< EventUsage > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_EventUsage_Sg__insert(rdcarray< EventUsage > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_EventUsage_Sg__pop(rdcarray< EventUsage > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_EventUsage_Sg__sort(rdcarray< EventUsage > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_EventUsage_Sg__copy(rdcarray< EventUsage > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_EventUsage_Sg__reverse(rdcarray< EventUsage > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_EventUsage_Sg__index(rdcarray< EventUsage > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_EventUsage_Sg__count(rdcarray< EventUsage > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_EventUsage_Sg__extend(rdcarray< EventUsage > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_EventUsage_Sg__remove(rdcarray< EventUsage > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<EventUsage> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_PathEntry_Sg__append(rdcarray< PathEntry > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_PathEntry_Sg__clear(rdcarray< PathEntry > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_PathEntry_Sg__insert(rdcarray< PathEntry > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_PathEntry_Sg__pop(rdcarray< PathEntry > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_PathEntry_Sg__sort(rdcarray< PathEntry > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_PathEntry_Sg__copy(rdcarray< PathEntry > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_PathEntry_Sg__reverse(rdcarray< PathEntry > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_PathEntry_Sg__index(rdcarray< PathEntry > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_PathEntry_Sg__count(rdcarray< PathEntry > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_PathEntry_Sg__extend(rdcarray< PathEntry > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_PathEntry_Sg__remove(rdcarray< PathEntry > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<PathEntry> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_PixelModification_Sg__append(rdcarray< PixelModification > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_PixelModification_Sg__clear(rdcarray< PixelModification > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_PixelModification_Sg__insert(rdcarray< PixelModification > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_PixelModification_Sg__pop(rdcarray< PixelModification > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_PixelModification_Sg__sort(rdcarray< PixelModification > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_PixelModification_Sg__copy(rdcarray< PixelModification > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_PixelModification_Sg__reverse(rdcarray< PixelModification > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_PixelModification_Sg__index(rdcarray< PixelModification > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_PixelModification_Sg__count(rdcarray< PixelModification > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_PixelModification_Sg__extend(rdcarray< PixelModification > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_PixelModification_Sg__remove(rdcarray< PixelModification > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<PixelModification> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_TaskGroupSize_Sg__append(rdcarray< TaskGroupSize > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_TaskGroupSize_Sg__clear(rdcarray< TaskGroupSize > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_TaskGroupSize_Sg__insert(rdcarray< TaskGroupSize > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_TaskGroupSize_Sg__pop(rdcarray< TaskGroupSize > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_TaskGroupSize_Sg__sort(rdcarray< TaskGroupSize > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_TaskGroupSize_Sg__copy(rdcarray< TaskGroupSize > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_TaskGroupSize_Sg__reverse(rdcarray< TaskGroupSize > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_TaskGroupSize_Sg__index(rdcarray< TaskGroupSize > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_TaskGroupSize_Sg__count(rdcarray< TaskGroupSize > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_TaskGroupSize_Sg__extend(rdcarray< TaskGroupSize > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_TaskGroupSize_Sg__remove(rdcarray< TaskGroupSize > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<TaskGroupSize> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_MeshletSize_Sg__append(rdcarray< MeshletSize > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_MeshletSize_Sg__clear(rdcarray< MeshletSize > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_MeshletSize_Sg__insert(rdcarray< MeshletSize > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_MeshletSize_Sg__pop(rdcarray< MeshletSize > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_MeshletSize_Sg__sort(rdcarray< MeshletSize > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_MeshletSize_Sg__copy(rdcarray< MeshletSize > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_MeshletSize_Sg__reverse(rdcarray< MeshletSize > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_MeshletSize_Sg__index(rdcarray< MeshletSize > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_MeshletSize_Sg__count(rdcarray< MeshletSize > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_MeshletSize_Sg__extend(rdcarray< MeshletSize > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_MeshletSize_Sg__remove(rdcarray< MeshletSize > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<MeshletSize> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ResourceDescription_Sg__append(rdcarray< ResourceDescription > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceDescription_Sg__clear(rdcarray< ResourceDescription > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceDescription_Sg__insert(rdcarray< ResourceDescription > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceDescription_Sg__pop(rdcarray< ResourceDescription > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceDescription_Sg__sort(rdcarray< ResourceDescription > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceDescription_Sg__copy(rdcarray< ResourceDescription > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceDescription_Sg__reverse(rdcarray< ResourceDescription > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceDescription_Sg__index(rdcarray< ResourceDescription > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceDescription_Sg__count(rdcarray< ResourceDescription > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceDescription_Sg__extend(rdcarray< ResourceDescription > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceDescription_Sg__remove(rdcarray< ResourceDescription > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ResourceDescription> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ResourceId_Sg__append(rdcarray< ResourceId > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceId_Sg__clear(rdcarray< ResourceId > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceId_Sg__insert(rdcarray< ResourceId > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceId_Sg__pop(rdcarray< ResourceId > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceId_Sg__sort(rdcarray< ResourceId > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceId_Sg__copy(rdcarray< ResourceId > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceId_Sg__reverse(rdcarray< ResourceId > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceId_Sg__index(rdcarray< ResourceId > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceId_Sg__count(rdcarray< ResourceId > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceId_Sg__extend(rdcarray< ResourceId > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceId_Sg__remove(rdcarray< ResourceId > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ResourceId> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_LineColumnInfo_Sg__append(rdcarray< LineColumnInfo > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_LineColumnInfo_Sg__clear(rdcarray< LineColumnInfo > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_LineColumnInfo_Sg__insert(rdcarray< LineColumnInfo > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_LineColumnInfo_Sg__pop(rdcarray< LineColumnInfo > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_LineColumnInfo_Sg__sort(rdcarray< LineColumnInfo > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_LineColumnInfo_Sg__copy(rdcarray< LineColumnInfo > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_LineColumnInfo_Sg__reverse(rdcarray< LineColumnInfo > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_LineColumnInfo_Sg__index(rdcarray< LineColumnInfo > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_LineColumnInfo_Sg__count(rdcarray< LineColumnInfo > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_LineColumnInfo_Sg__extend(rdcarray< LineColumnInfo > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_LineColumnInfo_Sg__remove(rdcarray< LineColumnInfo > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<LineColumnInfo> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_InstructionSourceInfo_Sg__append(rdcarray< InstructionSourceInfo > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_InstructionSourceInfo_Sg__clear(rdcarray< InstructionSourceInfo > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_InstructionSourceInfo_Sg__insert(rdcarray< InstructionSourceInfo > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_InstructionSourceInfo_Sg__pop(rdcarray< InstructionSourceInfo > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_InstructionSourceInfo_Sg__sort(rdcarray< InstructionSourceInfo > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_InstructionSourceInfo_Sg__copy(rdcarray< InstructionSourceInfo > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_InstructionSourceInfo_Sg__reverse(rdcarray< InstructionSourceInfo > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_InstructionSourceInfo_Sg__index(rdcarray< InstructionSourceInfo > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_InstructionSourceInfo_Sg__count(rdcarray< InstructionSourceInfo > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_InstructionSourceInfo_Sg__extend(rdcarray< InstructionSourceInfo > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_InstructionSourceInfo_Sg__remove(rdcarray< InstructionSourceInfo > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<InstructionSourceInfo> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderCompileFlag_Sg__append(rdcarray< ShaderCompileFlag > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderCompileFlag_Sg__clear(rdcarray< ShaderCompileFlag > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderCompileFlag_Sg__insert(rdcarray< ShaderCompileFlag > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderCompileFlag_Sg__pop(rdcarray< ShaderCompileFlag > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderCompileFlag_Sg__sort(rdcarray< ShaderCompileFlag > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderCompileFlag_Sg__copy(rdcarray< ShaderCompileFlag > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderCompileFlag_Sg__reverse(rdcarray< ShaderCompileFlag > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderCompileFlag_Sg__index(rdcarray< ShaderCompileFlag > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderCompileFlag_Sg__count(rdcarray< ShaderCompileFlag > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderCompileFlag_Sg__extend(rdcarray< ShaderCompileFlag > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderCompileFlag_Sg__remove(rdcarray< ShaderCompileFlag > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderCompileFlag> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderConstant_Sg__append(rdcarray< ShaderConstant > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstant_Sg__clear(rdcarray< ShaderConstant > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstant_Sg__insert(rdcarray< ShaderConstant > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstant_Sg__pop(rdcarray< ShaderConstant > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstant_Sg__sort(rdcarray< ShaderConstant > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstant_Sg__copy(rdcarray< ShaderConstant > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstant_Sg__reverse(rdcarray< ShaderConstant > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstant_Sg__index(rdcarray< ShaderConstant > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstant_Sg__count(rdcarray< ShaderConstant > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstant_Sg__extend(rdcarray< ShaderConstant > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstant_Sg__remove(rdcarray< ShaderConstant > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderConstant> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderDebugState_Sg__append(rdcarray< ShaderDebugState > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderDebugState_Sg__clear(rdcarray< ShaderDebugState > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderDebugState_Sg__insert(rdcarray< ShaderDebugState > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderDebugState_Sg__pop(rdcarray< ShaderDebugState > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderDebugState_Sg__sort(rdcarray< ShaderDebugState > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderDebugState_Sg__copy(rdcarray< ShaderDebugState > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderDebugState_Sg__reverse(rdcarray< ShaderDebugState > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderDebugState_Sg__index(rdcarray< ShaderDebugState > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderDebugState_Sg__count(rdcarray< ShaderDebugState > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderDebugState_Sg__extend(rdcarray< ShaderDebugState > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderDebugState_Sg__remove(rdcarray< ShaderDebugState > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderDebugState> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderMessage_Sg__append(rdcarray< ShaderMessage > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderMessage_Sg__clear(rdcarray< ShaderMessage > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderMessage_Sg__insert(rdcarray< ShaderMessage > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderMessage_Sg__pop(rdcarray< ShaderMessage > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderMessage_Sg__sort(rdcarray< ShaderMessage > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderMessage_Sg__copy(rdcarray< ShaderMessage > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderMessage_Sg__reverse(rdcarray< ShaderMessage > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderMessage_Sg__index(rdcarray< ShaderMessage > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderMessage_Sg__count(rdcarray< ShaderMessage > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderMessage_Sg__extend(rdcarray< ShaderMessage > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderMessage_Sg__remove(rdcarray< ShaderMessage > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderMessage> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderResource_Sg__append(rdcarray< ShaderResource > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderResource_Sg__clear(rdcarray< ShaderResource > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderResource_Sg__insert(rdcarray< ShaderResource > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderResource_Sg__pop(rdcarray< ShaderResource > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderResource_Sg__sort(rdcarray< ShaderResource > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderResource_Sg__copy(rdcarray< ShaderResource > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderResource_Sg__reverse(rdcarray< ShaderResource > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderResource_Sg__index(rdcarray< ShaderResource > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderResource_Sg__count(rdcarray< ShaderResource > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderResource_Sg__extend(rdcarray< ShaderResource > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderResource_Sg__remove(rdcarray< ShaderResource > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderResource> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderSampler_Sg__append(rdcarray< ShaderSampler > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSampler_Sg__clear(rdcarray< ShaderSampler > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSampler_Sg__insert(rdcarray< ShaderSampler > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSampler_Sg__pop(rdcarray< ShaderSampler > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSampler_Sg__sort(rdcarray< ShaderSampler > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSampler_Sg__copy(rdcarray< ShaderSampler > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSampler_Sg__reverse(rdcarray< ShaderSampler > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSampler_Sg__index(rdcarray< ShaderSampler > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSampler_Sg__count(rdcarray< ShaderSampler > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSampler_Sg__extend(rdcarray< ShaderSampler > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSampler_Sg__remove(rdcarray< ShaderSampler > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderSampler> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderSourceFile_Sg__append(rdcarray< ShaderSourceFile > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourceFile_Sg__clear(rdcarray< ShaderSourceFile > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourceFile_Sg__insert(rdcarray< ShaderSourceFile > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourceFile_Sg__pop(rdcarray< ShaderSourceFile > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourceFile_Sg__sort(rdcarray< ShaderSourceFile > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourceFile_Sg__copy(rdcarray< ShaderSourceFile > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourceFile_Sg__reverse(rdcarray< ShaderSourceFile > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourceFile_Sg__index(rdcarray< ShaderSourceFile > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourceFile_Sg__count(rdcarray< ShaderSourceFile > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourceFile_Sg__extend(rdcarray< ShaderSourceFile > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourceFile_Sg__remove(rdcarray< ShaderSourceFile > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderSourceFile> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderSourcePrefix_Sg__append(rdcarray< ShaderSourcePrefix > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourcePrefix_Sg__clear(rdcarray< ShaderSourcePrefix > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourcePrefix_Sg__insert(rdcarray< ShaderSourcePrefix > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourcePrefix_Sg__pop(rdcarray< ShaderSourcePrefix > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourcePrefix_Sg__sort(rdcarray< ShaderSourcePrefix > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourcePrefix_Sg__copy(rdcarray< ShaderSourcePrefix > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourcePrefix_Sg__reverse(rdcarray< ShaderSourcePrefix > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourcePrefix_Sg__index(rdcarray< ShaderSourcePrefix > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourcePrefix_Sg__count(rdcarray< ShaderSourcePrefix > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourcePrefix_Sg__extend(rdcarray< ShaderSourcePrefix > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderSourcePrefix_Sg__remove(rdcarray< ShaderSourcePrefix > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderSourcePrefix> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderVariable_Sg__append(rdcarray< ShaderVariable > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariable_Sg__clear(rdcarray< ShaderVariable > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariable_Sg__insert(rdcarray< ShaderVariable > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariable_Sg__pop(rdcarray< ShaderVariable > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariable_Sg__sort(rdcarray< ShaderVariable > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariable_Sg__copy(rdcarray< ShaderVariable > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariable_Sg__reverse(rdcarray< ShaderVariable > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariable_Sg__index(rdcarray< ShaderVariable > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariable_Sg__count(rdcarray< ShaderVariable > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariable_Sg__extend(rdcarray< ShaderVariable > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariable_Sg__remove(rdcarray< ShaderVariable > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderVariable> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderEncoding_Sg__append(rdcarray< ShaderEncoding > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEncoding_Sg__clear(rdcarray< ShaderEncoding > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEncoding_Sg__insert(rdcarray< ShaderEncoding > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEncoding_Sg__pop(rdcarray< ShaderEncoding > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEncoding_Sg__sort(rdcarray< ShaderEncoding > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEncoding_Sg__copy(rdcarray< ShaderEncoding > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEncoding_Sg__reverse(rdcarray< ShaderEncoding > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEncoding_Sg__index(rdcarray< ShaderEncoding > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEncoding_Sg__count(rdcarray< ShaderEncoding > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEncoding_Sg__extend(rdcarray< ShaderEncoding > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEncoding_Sg__remove(rdcarray< ShaderEncoding > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderEncoding> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderVariableChange_Sg__append(rdcarray< ShaderVariableChange > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariableChange_Sg__clear(rdcarray< ShaderVariableChange > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariableChange_Sg__insert(rdcarray< ShaderVariableChange > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariableChange_Sg__pop(rdcarray< ShaderVariableChange > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariableChange_Sg__sort(rdcarray< ShaderVariableChange > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariableChange_Sg__copy(rdcarray< ShaderVariableChange > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariableChange_Sg__reverse(rdcarray< ShaderVariableChange > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariableChange_Sg__index(rdcarray< ShaderVariableChange > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariableChange_Sg__count(rdcarray< ShaderVariableChange > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariableChange_Sg__extend(rdcarray< ShaderVariableChange > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderVariableChange_Sg__remove(rdcarray< ShaderVariableChange > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderVariableChange> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_DebugVariableReference_Sg__append(rdcarray< DebugVariableReference > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugVariableReference_Sg__clear(rdcarray< DebugVariableReference > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugVariableReference_Sg__insert(rdcarray< DebugVariableReference > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugVariableReference_Sg__pop(rdcarray< DebugVariableReference > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugVariableReference_Sg__sort(rdcarray< DebugVariableReference > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugVariableReference_Sg__copy(rdcarray< DebugVariableReference > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugVariableReference_Sg__reverse(rdcarray< DebugVariableReference > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugVariableReference_Sg__index(rdcarray< DebugVariableReference > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugVariableReference_Sg__count(rdcarray< DebugVariableReference > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugVariableReference_Sg__extend(rdcarray< DebugVariableReference > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_DebugVariableReference_Sg__remove(rdcarray< DebugVariableReference > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<DebugVariableReference> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_SourceVariableMapping_Sg__append(rdcarray< SourceVariableMapping > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_SourceVariableMapping_Sg__clear(rdcarray< SourceVariableMapping > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_SourceVariableMapping_Sg__insert(rdcarray< SourceVariableMapping > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_SourceVariableMapping_Sg__pop(rdcarray< SourceVariableMapping > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_SourceVariableMapping_Sg__sort(rdcarray< SourceVariableMapping > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_SourceVariableMapping_Sg__copy(rdcarray< SourceVariableMapping > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_SourceVariableMapping_Sg__reverse(rdcarray< SourceVariableMapping > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_SourceVariableMapping_Sg__index(rdcarray< SourceVariableMapping > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_SourceVariableMapping_Sg__count(rdcarray< SourceVariableMapping > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_SourceVariableMapping_Sg__extend(rdcarray< SourceVariableMapping > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_SourceVariableMapping_Sg__remove(rdcarray< SourceVariableMapping > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<SourceVariableMapping> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_SigParameter_Sg__append(rdcarray< SigParameter > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_SigParameter_Sg__clear(rdcarray< SigParameter > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_SigParameter_Sg__insert(rdcarray< SigParameter > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_SigParameter_Sg__pop(rdcarray< SigParameter > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_SigParameter_Sg__sort(rdcarray< SigParameter > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_SigParameter_Sg__copy(rdcarray< SigParameter > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_SigParameter_Sg__reverse(rdcarray< SigParameter > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_SigParameter_Sg__index(rdcarray< SigParameter > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_SigParameter_Sg__count(rdcarray< SigParameter > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_SigParameter_Sg__extend(rdcarray< SigParameter > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_SigParameter_Sg__remove(rdcarray< SigParameter > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<SigParameter> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_TextureDescription_Sg__append(rdcarray< TextureDescription > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_TextureDescription_Sg__clear(rdcarray< TextureDescription > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_TextureDescription_Sg__insert(rdcarray< TextureDescription > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_TextureDescription_Sg__pop(rdcarray< TextureDescription > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_TextureDescription_Sg__sort(rdcarray< TextureDescription > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_TextureDescription_Sg__copy(rdcarray< TextureDescription > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_TextureDescription_Sg__reverse(rdcarray< TextureDescription > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_TextureDescription_Sg__index(rdcarray< TextureDescription > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_TextureDescription_Sg__count(rdcarray< TextureDescription > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_TextureDescription_Sg__extend(rdcarray< TextureDescription > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_TextureDescription_Sg__remove(rdcarray< TextureDescription > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<TextureDescription> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderEntryPoint_Sg__append(rdcarray< ShaderEntryPoint > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEntryPoint_Sg__clear(rdcarray< ShaderEntryPoint > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEntryPoint_Sg__insert(rdcarray< ShaderEntryPoint > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEntryPoint_Sg__pop(rdcarray< ShaderEntryPoint > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEntryPoint_Sg__sort(rdcarray< ShaderEntryPoint > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEntryPoint_Sg__copy(rdcarray< ShaderEntryPoint > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEntryPoint_Sg__reverse(rdcarray< ShaderEntryPoint > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEntryPoint_Sg__index(rdcarray< ShaderEntryPoint > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEntryPoint_Sg__count(rdcarray< ShaderEntryPoint > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEntryPoint_Sg__extend(rdcarray< ShaderEntryPoint > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderEntryPoint_Sg__remove(rdcarray< ShaderEntryPoint > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderEntryPoint> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_Viewport_Sg__append(rdcarray< Viewport > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_Viewport_Sg__clear(rdcarray< Viewport > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_Viewport_Sg__insert(rdcarray< Viewport > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_Viewport_Sg__pop(rdcarray< Viewport > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_Viewport_Sg__sort(rdcarray< Viewport > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_Viewport_Sg__copy(rdcarray< Viewport > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_Viewport_Sg__reverse(rdcarray< Viewport > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_Viewport_Sg__index(rdcarray< Viewport > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_Viewport_Sg__count(rdcarray< Viewport > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_Viewport_Sg__extend(rdcarray< Viewport > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_Viewport_Sg__remove(rdcarray< Viewport > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<Viewport> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_Scissor_Sg__append(rdcarray< Scissor > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_Scissor_Sg__clear(rdcarray< Scissor > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_Scissor_Sg__insert(rdcarray< Scissor > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_Scissor_Sg__pop(rdcarray< Scissor > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_Scissor_Sg__sort(rdcarray< Scissor > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_Scissor_Sg__copy(rdcarray< Scissor > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_Scissor_Sg__reverse(rdcarray< Scissor > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_Scissor_Sg__index(rdcarray< Scissor > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_Scissor_Sg__count(rdcarray< Scissor > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_Scissor_Sg__extend(rdcarray< Scissor > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_Scissor_Sg__remove(rdcarray< Scissor > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<Scissor> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ColorBlend_Sg__append(rdcarray< ColorBlend > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ColorBlend_Sg__clear(rdcarray< ColorBlend > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ColorBlend_Sg__insert(rdcarray< ColorBlend > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ColorBlend_Sg__pop(rdcarray< ColorBlend > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ColorBlend_Sg__sort(rdcarray< ColorBlend > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ColorBlend_Sg__copy(rdcarray< ColorBlend > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ColorBlend_Sg__reverse(rdcarray< ColorBlend > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ColorBlend_Sg__index(rdcarray< ColorBlend > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ColorBlend_Sg__count(rdcarray< ColorBlend > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ColorBlend_Sg__extend(rdcarray< ColorBlend > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ColorBlend_Sg__remove(rdcarray< ColorBlend > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ColorBlend> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_BoundVBuffer_Sg__append(rdcarray< BoundVBuffer > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_BoundVBuffer_Sg__clear(rdcarray< BoundVBuffer > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_BoundVBuffer_Sg__insert(rdcarray< BoundVBuffer > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_BoundVBuffer_Sg__pop(rdcarray< BoundVBuffer > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_BoundVBuffer_Sg__sort(rdcarray< BoundVBuffer > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_BoundVBuffer_Sg__copy(rdcarray< BoundVBuffer > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_BoundVBuffer_Sg__reverse(rdcarray< BoundVBuffer > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_BoundVBuffer_Sg__index(rdcarray< BoundVBuffer > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_BoundVBuffer_Sg__count(rdcarray< BoundVBuffer > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_BoundVBuffer_Sg__extend(rdcarray< BoundVBuffer > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_BoundVBuffer_Sg__remove(rdcarray< BoundVBuffer > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<BoundVBuffer> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_Offset_Sg__append(rdcarray< Offset > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_Offset_Sg__clear(rdcarray< Offset > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_Offset_Sg__insert(rdcarray< Offset > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_Offset_Sg__pop(rdcarray< Offset > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_Offset_Sg__sort(rdcarray< Offset > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_Offset_Sg__copy(rdcarray< Offset > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_Offset_Sg__reverse(rdcarray< Offset > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_Offset_Sg__index(rdcarray< Offset > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_Offset_Sg__count(rdcarray< Offset > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_Offset_Sg__extend(rdcarray< Offset > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_Offset_Sg__remove(rdcarray< Offset > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<Offset> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_VertexInputAttribute_Sg__append(rdcarray< VertexInputAttribute > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VertexInputAttribute_Sg__clear(rdcarray< VertexInputAttribute > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VertexInputAttribute_Sg__insert(rdcarray< VertexInputAttribute > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VertexInputAttribute_Sg__pop(rdcarray< VertexInputAttribute > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_VertexInputAttribute_Sg__sort(rdcarray< VertexInputAttribute > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_VertexInputAttribute_Sg__copy(rdcarray< VertexInputAttribute > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VertexInputAttribute_Sg__reverse(rdcarray< VertexInputAttribute > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VertexInputAttribute_Sg__index(rdcarray< VertexInputAttribute > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_VertexInputAttribute_Sg__count(rdcarray< VertexInputAttribute > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_VertexInputAttribute_Sg__extend(rdcarray< VertexInputAttribute > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_VertexInputAttribute_Sg__remove(rdcarray< VertexInputAttribute > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<VertexInputAttribute> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_FloatVector_Sg__append(rdcarray< FloatVector > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_FloatVector_Sg__clear(rdcarray< FloatVector > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_FloatVector_Sg__insert(rdcarray< FloatVector > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_FloatVector_Sg__pop(rdcarray< FloatVector > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_FloatVector_Sg__sort(rdcarray< FloatVector > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_FloatVector_Sg__copy(rdcarray< FloatVector > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_FloatVector_Sg__reverse(rdcarray< FloatVector > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_FloatVector_Sg__index(rdcarray< FloatVector > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_FloatVector_Sg__count(rdcarray< FloatVector > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_FloatVector_Sg__extend(rdcarray< FloatVector > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_FloatVector_Sg__remove(rdcarray< FloatVector > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<FloatVector> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_GraphicsAPI_Sg__append(rdcarray< GraphicsAPI > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_GraphicsAPI_Sg__clear(rdcarray< GraphicsAPI > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GraphicsAPI_Sg__insert(rdcarray< GraphicsAPI > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_GraphicsAPI_Sg__pop(rdcarray< GraphicsAPI > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_GraphicsAPI_Sg__sort(rdcarray< GraphicsAPI > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_GraphicsAPI_Sg__copy(rdcarray< GraphicsAPI > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GraphicsAPI_Sg__reverse(rdcarray< GraphicsAPI > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GraphicsAPI_Sg__index(rdcarray< GraphicsAPI > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_GraphicsAPI_Sg__count(rdcarray< GraphicsAPI > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_GraphicsAPI_Sg__extend(rdcarray< GraphicsAPI > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_GraphicsAPI_Sg__remove(rdcarray< GraphicsAPI > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<GraphicsAPI> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_GPUDevice_Sg__append(rdcarray< GPUDevice > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUDevice_Sg__clear(rdcarray< GPUDevice > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUDevice_Sg__insert(rdcarray< GPUDevice > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUDevice_Sg__pop(rdcarray< GPUDevice > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUDevice_Sg__sort(rdcarray< GPUDevice > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUDevice_Sg__copy(rdcarray< GPUDevice > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUDevice_Sg__reverse(rdcarray< GPUDevice > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUDevice_Sg__index(rdcarray< GPUDevice > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUDevice_Sg__count(rdcarray< GPUDevice > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUDevice_Sg__extend(rdcarray< GPUDevice > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_GPUDevice_Sg__remove(rdcarray< GPUDevice > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<GPUDevice> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderConstantType_Sg__append(rdcarray< ShaderConstantType > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstantType_Sg__clear(rdcarray< ShaderConstantType > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstantType_Sg__insert(rdcarray< ShaderConstantType > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstantType_Sg__pop(rdcarray< ShaderConstantType > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstantType_Sg__sort(rdcarray< ShaderConstantType > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstantType_Sg__copy(rdcarray< ShaderConstantType > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstantType_Sg__reverse(rdcarray< ShaderConstantType > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstantType_Sg__index(rdcarray< ShaderConstantType > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstantType_Sg__count(rdcarray< ShaderConstantType > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstantType_Sg__extend(rdcarray< ShaderConstantType > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderConstantType_Sg__remove(rdcarray< ShaderConstantType > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderConstantType> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ShaderChangeStats_Sg__append(rdcarray< ShaderChangeStats > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderChangeStats_Sg__clear(rdcarray< ShaderChangeStats > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderChangeStats_Sg__insert(rdcarray< ShaderChangeStats > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderChangeStats_Sg__pop(rdcarray< ShaderChangeStats > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderChangeStats_Sg__sort(rdcarray< ShaderChangeStats > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderChangeStats_Sg__copy(rdcarray< ShaderChangeStats > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderChangeStats_Sg__reverse(rdcarray< ShaderChangeStats > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderChangeStats_Sg__index(rdcarray< ShaderChangeStats > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderChangeStats_Sg__count(rdcarray< ShaderChangeStats > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderChangeStats_Sg__extend(rdcarray< ShaderChangeStats > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ShaderChangeStats_Sg__remove(rdcarray< ShaderChangeStats > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ShaderChangeStats> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ResourceBindStats_Sg__append(rdcarray< ResourceBindStats > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceBindStats_Sg__clear(rdcarray< ResourceBindStats > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceBindStats_Sg__insert(rdcarray< ResourceBindStats > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceBindStats_Sg__pop(rdcarray< ResourceBindStats > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceBindStats_Sg__sort(rdcarray< ResourceBindStats > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceBindStats_Sg__copy(rdcarray< ResourceBindStats > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceBindStats_Sg__reverse(rdcarray< ResourceBindStats > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceBindStats_Sg__index(rdcarray< ResourceBindStats > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceBindStats_Sg__count(rdcarray< ResourceBindStats > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceBindStats_Sg__extend(rdcarray< ResourceBindStats > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ResourceBindStats_Sg__remove(rdcarray< ResourceBindStats > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ResourceBindStats> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_SamplerBindStats_Sg__append(rdcarray< SamplerBindStats > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerBindStats_Sg__clear(rdcarray< SamplerBindStats > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerBindStats_Sg__insert(rdcarray< SamplerBindStats > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerBindStats_Sg__pop(rdcarray< SamplerBindStats > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerBindStats_Sg__sort(rdcarray< SamplerBindStats > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerBindStats_Sg__copy(rdcarray< SamplerBindStats > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerBindStats_Sg__reverse(rdcarray< SamplerBindStats > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerBindStats_Sg__index(rdcarray< SamplerBindStats > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerBindStats_Sg__count(rdcarray< SamplerBindStats > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerBindStats_Sg__extend(rdcarray< SamplerBindStats > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerBindStats_Sg__remove(rdcarray< SamplerBindStats > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<SamplerBindStats> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_ConstantBindStats_Sg__append(rdcarray< ConstantBindStats > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBindStats_Sg__clear(rdcarray< ConstantBindStats > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBindStats_Sg__insert(rdcarray< ConstantBindStats > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBindStats_Sg__pop(rdcarray< ConstantBindStats > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBindStats_Sg__sort(rdcarray< ConstantBindStats > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBindStats_Sg__copy(rdcarray< ConstantBindStats > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBindStats_Sg__reverse(rdcarray< ConstantBindStats > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBindStats_Sg__index(rdcarray< ConstantBindStats > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBindStats_Sg__count(rdcarray< ConstantBindStats > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBindStats_Sg__extend(rdcarray< ConstantBindStats > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_ConstantBindStats_Sg__remove(rdcarray< ConstantBindStats > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<ConstantBindStats> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_DescriptorRange_Sg__append(rdcarray< DescriptorRange > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorRange_Sg__clear(rdcarray< DescriptorRange > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorRange_Sg__insert(rdcarray< DescriptorRange > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorRange_Sg__pop(rdcarray< DescriptorRange > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorRange_Sg__sort(rdcarray< DescriptorRange > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorRange_Sg__copy(rdcarray< DescriptorRange > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorRange_Sg__reverse(rdcarray< DescriptorRange > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorRange_Sg__index(rdcarray< DescriptorRange > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorRange_Sg__count(rdcarray< DescriptorRange > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorRange_Sg__extend(rdcarray< DescriptorRange > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorRange_Sg__remove(rdcarray< DescriptorRange > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<DescriptorRange> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_Descriptor_Sg__append(rdcarray< Descriptor > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_Descriptor_Sg__clear(rdcarray< Descriptor > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_Descriptor_Sg__insert(rdcarray< Descriptor > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_Descriptor_Sg__pop(rdcarray< Descriptor > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_Descriptor_Sg__sort(rdcarray< Descriptor > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_Descriptor_Sg__copy(rdcarray< Descriptor > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_Descriptor_Sg__reverse(rdcarray< Descriptor > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_Descriptor_Sg__index(rdcarray< Descriptor > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_Descriptor_Sg__count(rdcarray< Descriptor > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_Descriptor_Sg__extend(rdcarray< Descriptor > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_Descriptor_Sg__remove(rdcarray< Descriptor > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<Descriptor> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_SamplerDescriptor_Sg__append(rdcarray< SamplerDescriptor > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerDescriptor_Sg__clear(rdcarray< SamplerDescriptor > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerDescriptor_Sg__insert(rdcarray< SamplerDescriptor > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerDescriptor_Sg__pop(rdcarray< SamplerDescriptor > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerDescriptor_Sg__sort(rdcarray< SamplerDescriptor > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerDescriptor_Sg__copy(rdcarray< SamplerDescriptor > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerDescriptor_Sg__reverse(rdcarray< SamplerDescriptor > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerDescriptor_Sg__index(rdcarray< SamplerDescriptor > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerDescriptor_Sg__count(rdcarray< SamplerDescriptor > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerDescriptor_Sg__extend(rdcarray< SamplerDescriptor > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_SamplerDescriptor_Sg__remove(rdcarray< SamplerDescriptor > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<SamplerDescriptor> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_DescriptorAccess_Sg__append(rdcarray< DescriptorAccess > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorAccess_Sg__clear(rdcarray< DescriptorAccess > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorAccess_Sg__insert(rdcarray< DescriptorAccess > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorAccess_Sg__pop(rdcarray< DescriptorAccess > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorAccess_Sg__sort(rdcarray< DescriptorAccess > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorAccess_Sg__copy(rdcarray< DescriptorAccess > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorAccess_Sg__reverse(rdcarray< DescriptorAccess > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorAccess_Sg__index(rdcarray< DescriptorAccess > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorAccess_Sg__count(rdcarray< DescriptorAccess > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorAccess_Sg__extend(rdcarray< DescriptorAccess > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorAccess_Sg__remove(rdcarray< DescriptorAccess > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<DescriptorAccess> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_DescriptorLogicalLocation_Sg__append(rdcarray< DescriptorLogicalLocation > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorLogicalLocation_Sg__clear(rdcarray< DescriptorLogicalLocation > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorLogicalLocation_Sg__insert(rdcarray< DescriptorLogicalLocation > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorLogicalLocation_Sg__pop(rdcarray< DescriptorLogicalLocation > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorLogicalLocation_Sg__sort(rdcarray< DescriptorLogicalLocation > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorLogicalLocation_Sg__copy(rdcarray< DescriptorLogicalLocation > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorLogicalLocation_Sg__reverse(rdcarray< DescriptorLogicalLocation > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorLogicalLocation_Sg__index(rdcarray< DescriptorLogicalLocation > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorLogicalLocation_Sg__count(rdcarray< DescriptorLogicalLocation > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorLogicalLocation_Sg__extend(rdcarray< DescriptorLogicalLocation > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_DescriptorLogicalLocation_Sg__remove(rdcarray< DescriptorLogicalLocation > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<DescriptorLogicalLocation> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_UsedDescriptor_Sg__append(rdcarray< UsedDescriptor > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_UsedDescriptor_Sg__clear(rdcarray< UsedDescriptor > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_UsedDescriptor_Sg__insert(rdcarray< UsedDescriptor > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_UsedDescriptor_Sg__pop(rdcarray< UsedDescriptor > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_UsedDescriptor_Sg__sort(rdcarray< UsedDescriptor > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_UsedDescriptor_Sg__copy(rdcarray< UsedDescriptor > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_UsedDescriptor_Sg__reverse(rdcarray< UsedDescriptor > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_UsedDescriptor_Sg__index(rdcarray< UsedDescriptor > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_UsedDescriptor_Sg__count(rdcarray< UsedDescriptor > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_UsedDescriptor_Sg__extend(rdcarray< UsedDescriptor > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_UsedDescriptor_Sg__remove(rdcarray< UsedDescriptor > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<UsedDescriptor> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DynamicOffset_Sg__append(rdcarray< VKPipe::DynamicOffset > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DynamicOffset_Sg__clear(rdcarray< VKPipe::DynamicOffset > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DynamicOffset_Sg__insert(rdcarray< VKPipe::DynamicOffset > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DynamicOffset_Sg__pop(rdcarray< VKPipe::DynamicOffset > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DynamicOffset_Sg__sort(rdcarray< VKPipe::DynamicOffset > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DynamicOffset_Sg__copy(rdcarray< VKPipe::DynamicOffset > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DynamicOffset_Sg__reverse(rdcarray< VKPipe::DynamicOffset > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DynamicOffset_Sg__index(rdcarray< VKPipe::DynamicOffset > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DynamicOffset_Sg__count(rdcarray< VKPipe::DynamicOffset > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DynamicOffset_Sg__extend(rdcarray< VKPipe::DynamicOffset > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DynamicOffset_Sg__remove(rdcarray< VKPipe::DynamicOffset > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<VKPipe::DynamicOffset> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorSet_Sg__append(rdcarray< VKPipe::DescriptorSet > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorSet_Sg__clear(rdcarray< VKPipe::DescriptorSet > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorSet_Sg__insert(rdcarray< VKPipe::DescriptorSet > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorSet_Sg__pop(rdcarray< VKPipe::DescriptorSet > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorSet_Sg__sort(rdcarray< VKPipe::DescriptorSet > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorSet_Sg__copy(rdcarray< VKPipe::DescriptorSet > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorSet_Sg__reverse(rdcarray< VKPipe::DescriptorSet > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorSet_Sg__index(rdcarray< VKPipe::DescriptorSet > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorSet_Sg__count(rdcarray< VKPipe::DescriptorSet > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorSet_Sg__extend(rdcarray< VKPipe::DescriptorSet > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorSet_Sg__remove(rdcarray< VKPipe::DescriptorSet > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<VKPipe::DescriptorSet> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__append(rdcarray< VKPipe::DescriptorBuffer > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__clear(rdcarray< VKPipe::DescriptorBuffer > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__insert(rdcarray< VKPipe::DescriptorBuffer > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__pop(rdcarray< VKPipe::DescriptorBuffer > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__sort(rdcarray< VKPipe::DescriptorBuffer > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__copy(rdcarray< VKPipe::DescriptorBuffer > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__reverse(rdcarray< VKPipe::DescriptorBuffer > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__index(rdcarray< VKPipe::DescriptorBuffer > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__count(rdcarray< VKPipe::DescriptorBuffer > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__extend(rdcarray< VKPipe::DescriptorBuffer > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__remove(rdcarray< VKPipe::DescriptorBuffer > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<VKPipe::DescriptorBuffer> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageData_Sg__append(rdcarray< VKPipe::ImageData > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageData_Sg__clear(rdcarray< VKPipe::ImageData > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageData_Sg__insert(rdcarray< VKPipe::ImageData > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageData_Sg__pop(rdcarray< VKPipe::ImageData > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageData_Sg__sort(rdcarray< VKPipe::ImageData > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageData_Sg__copy(rdcarray< VKPipe::ImageData > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageData_Sg__reverse(rdcarray< VKPipe::ImageData > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageData_Sg__index(rdcarray< VKPipe::ImageData > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageData_Sg__count(rdcarray< VKPipe::ImageData > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageData_Sg__extend(rdcarray< VKPipe::ImageData > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageData_Sg__remove(rdcarray< VKPipe::ImageData > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<VKPipe::ImageData> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageLayout_Sg__append(rdcarray< VKPipe::ImageLayout > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageLayout_Sg__clear(rdcarray< VKPipe::ImageLayout > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageLayout_Sg__insert(rdcarray< VKPipe::ImageLayout > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageLayout_Sg__pop(rdcarray< VKPipe::ImageLayout > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageLayout_Sg__sort(rdcarray< VKPipe::ImageLayout > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageLayout_Sg__copy(rdcarray< VKPipe::ImageLayout > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageLayout_Sg__reverse(rdcarray< VKPipe::ImageLayout > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageLayout_Sg__index(rdcarray< VKPipe::ImageLayout > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageLayout_Sg__count(rdcarray< VKPipe::ImageLayout > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageLayout_Sg__extend(rdcarray< VKPipe::ImageLayout > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ImageLayout_Sg__remove(rdcarray< VKPipe::ImageLayout > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<VKPipe::ImageLayout> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_VKPipe_RenderArea_Sg__append(rdcarray< VKPipe::RenderArea > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_RenderArea_Sg__clear(rdcarray< VKPipe::RenderArea > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_RenderArea_Sg__insert(rdcarray< VKPipe::RenderArea > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_RenderArea_Sg__pop(rdcarray< VKPipe::RenderArea > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_RenderArea_Sg__sort(rdcarray< VKPipe::RenderArea > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_RenderArea_Sg__copy(rdcarray< VKPipe::RenderArea > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_RenderArea_Sg__reverse(rdcarray< VKPipe::RenderArea > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_RenderArea_Sg__index(rdcarray< VKPipe::RenderArea > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_RenderArea_Sg__count(rdcarray< VKPipe::RenderArea > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_RenderArea_Sg__extend(rdcarray< VKPipe::RenderArea > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_RenderArea_Sg__remove(rdcarray< VKPipe::RenderArea > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<VKPipe::RenderArea> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_VKPipe_XFBBuffer_Sg__append(rdcarray< VKPipe::XFBBuffer > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_XFBBuffer_Sg__clear(rdcarray< VKPipe::XFBBuffer > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_XFBBuffer_Sg__insert(rdcarray< VKPipe::XFBBuffer > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_XFBBuffer_Sg__pop(rdcarray< VKPipe::XFBBuffer > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_XFBBuffer_Sg__sort(rdcarray< VKPipe::XFBBuffer > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_XFBBuffer_Sg__copy(rdcarray< VKPipe::XFBBuffer > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_XFBBuffer_Sg__reverse(rdcarray< VKPipe::XFBBuffer > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_XFBBuffer_Sg__index(rdcarray< VKPipe::XFBBuffer > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_XFBBuffer_Sg__count(rdcarray< VKPipe::XFBBuffer > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_XFBBuffer_Sg__extend(rdcarray< VKPipe::XFBBuffer > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_XFBBuffer_Sg__remove(rdcarray< VKPipe::XFBBuffer > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<VKPipe::XFBBuffer> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBuffer_Sg__append(rdcarray< VKPipe::VertexBuffer > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBuffer_Sg__clear(rdcarray< VKPipe::VertexBuffer > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBuffer_Sg__insert(rdcarray< VKPipe::VertexBuffer > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBuffer_Sg__pop(rdcarray< VKPipe::VertexBuffer > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBuffer_Sg__sort(rdcarray< VKPipe::VertexBuffer > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBuffer_Sg__copy(rdcarray< VKPipe::VertexBuffer > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBuffer_Sg__reverse(rdcarray< VKPipe::VertexBuffer > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBuffer_Sg__index(rdcarray< VKPipe::VertexBuffer > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBuffer_Sg__count(rdcarray< VKPipe::VertexBuffer > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBuffer_Sg__extend(rdcarray< VKPipe::VertexBuffer > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBuffer_Sg__remove(rdcarray< VKPipe::VertexBuffer > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<VKPipe::VertexBuffer> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexAttribute_Sg__append(rdcarray< VKPipe::VertexAttribute > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexAttribute_Sg__clear(rdcarray< VKPipe::VertexAttribute > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexAttribute_Sg__insert(rdcarray< VKPipe::VertexAttribute > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexAttribute_Sg__pop(rdcarray< VKPipe::VertexAttribute > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexAttribute_Sg__sort(rdcarray< VKPipe::VertexAttribute > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexAttribute_Sg__copy(rdcarray< VKPipe::VertexAttribute > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexAttribute_Sg__reverse(rdcarray< VKPipe::VertexAttribute > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexAttribute_Sg__index(rdcarray< VKPipe::VertexAttribute > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexAttribute_Sg__count(rdcarray< VKPipe::VertexAttribute > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexAttribute_Sg__extend(rdcarray< VKPipe::VertexAttribute > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexAttribute_Sg__remove(rdcarray< VKPipe::VertexAttribute > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<VKPipe::VertexAttribute> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBinding_Sg__append(rdcarray< VKPipe::VertexBinding > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBinding_Sg__clear(rdcarray< VKPipe::VertexBinding > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBinding_Sg__insert(rdcarray< VKPipe::VertexBinding > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBinding_Sg__pop(rdcarray< VKPipe::VertexBinding > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBinding_Sg__sort(rdcarray< VKPipe::VertexBinding > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBinding_Sg__copy(rdcarray< VKPipe::VertexBinding > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBinding_Sg__reverse(rdcarray< VKPipe::VertexBinding > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBinding_Sg__index(rdcarray< VKPipe::VertexBinding > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBinding_Sg__count(rdcarray< VKPipe::VertexBinding > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBinding_Sg__extend(rdcarray< VKPipe::VertexBinding > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_VertexBinding_Sg__remove(rdcarray< VKPipe::VertexBinding > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<VKPipe::VertexBinding> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ViewportScissor_Sg__append(rdcarray< VKPipe::ViewportScissor > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ViewportScissor_Sg__clear(rdcarray< VKPipe::ViewportScissor > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ViewportScissor_Sg__insert(rdcarray< VKPipe::ViewportScissor > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ViewportScissor_Sg__pop(rdcarray< VKPipe::ViewportScissor > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ViewportScissor_Sg__sort(rdcarray< VKPipe::ViewportScissor > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ViewportScissor_Sg__copy(rdcarray< VKPipe::ViewportScissor > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ViewportScissor_Sg__reverse(rdcarray< VKPipe::ViewportScissor > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ViewportScissor_Sg__index(rdcarray< VKPipe::ViewportScissor > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ViewportScissor_Sg__count(rdcarray< VKPipe::ViewportScissor > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ViewportScissor_Sg__extend(rdcarray< VKPipe::ViewportScissor > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_VKPipe_ViewportScissor_Sg__remove(rdcarray< VKPipe::ViewportScissor > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<VKPipe::ViewportScissor> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_Layout_Sg__append(rdcarray< D3D11Pipe::Layout > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_Layout_Sg__clear(rdcarray< D3D11Pipe::Layout > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_Layout_Sg__insert(rdcarray< D3D11Pipe::Layout > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_Layout_Sg__pop(rdcarray< D3D11Pipe::Layout > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_Layout_Sg__sort(rdcarray< D3D11Pipe::Layout > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_Layout_Sg__copy(rdcarray< D3D11Pipe::Layout > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_Layout_Sg__reverse(rdcarray< D3D11Pipe::Layout > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_Layout_Sg__index(rdcarray< D3D11Pipe::Layout > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_Layout_Sg__count(rdcarray< D3D11Pipe::Layout > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_Layout_Sg__extend(rdcarray< D3D11Pipe::Layout > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_Layout_Sg__remove(rdcarray< D3D11Pipe::Layout > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<D3D11Pipe::Layout> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__append(rdcarray< D3D11Pipe::StreamOutBind > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__clear(rdcarray< D3D11Pipe::StreamOutBind > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__insert(rdcarray< D3D11Pipe::StreamOutBind > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__pop(rdcarray< D3D11Pipe::StreamOutBind > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__sort(rdcarray< D3D11Pipe::StreamOutBind > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__copy(rdcarray< D3D11Pipe::StreamOutBind > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__reverse(rdcarray< D3D11Pipe::StreamOutBind > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__index(rdcarray< D3D11Pipe::StreamOutBind > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__count(rdcarray< D3D11Pipe::StreamOutBind > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__extend(rdcarray< D3D11Pipe::StreamOutBind > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__remove(rdcarray< D3D11Pipe::StreamOutBind > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<D3D11Pipe::StreamOutBind> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__append(rdcarray< D3D11Pipe::VertexBuffer > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__clear(rdcarray< D3D11Pipe::VertexBuffer > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__insert(rdcarray< D3D11Pipe::VertexBuffer > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__pop(rdcarray< D3D11Pipe::VertexBuffer > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__sort(rdcarray< D3D11Pipe::VertexBuffer > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__copy(rdcarray< D3D11Pipe::VertexBuffer > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__reverse(rdcarray< D3D11Pipe::VertexBuffer > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__index(rdcarray< D3D11Pipe::VertexBuffer > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__count(rdcarray< D3D11Pipe::VertexBuffer > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__extend(rdcarray< D3D11Pipe::VertexBuffer > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__remove(rdcarray< D3D11Pipe::VertexBuffer > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<D3D11Pipe::VertexBuffer> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_Layout_Sg__append(rdcarray< D3D12Pipe::Layout > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_Layout_Sg__clear(rdcarray< D3D12Pipe::Layout > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_Layout_Sg__insert(rdcarray< D3D12Pipe::Layout > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_Layout_Sg__pop(rdcarray< D3D12Pipe::Layout > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_Layout_Sg__sort(rdcarray< D3D12Pipe::Layout > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_Layout_Sg__copy(rdcarray< D3D12Pipe::Layout > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_Layout_Sg__reverse(rdcarray< D3D12Pipe::Layout > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_Layout_Sg__index(rdcarray< D3D12Pipe::Layout > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_Layout_Sg__count(rdcarray< D3D12Pipe::Layout > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_Layout_Sg__extend(rdcarray< D3D12Pipe::Layout > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_Layout_Sg__remove(rdcarray< D3D12Pipe::Layout > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<D3D12Pipe::Layout> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceData_Sg__append(rdcarray< D3D12Pipe::ResourceData > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceData_Sg__clear(rdcarray< D3D12Pipe::ResourceData > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceData_Sg__insert(rdcarray< D3D12Pipe::ResourceData > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceData_Sg__pop(rdcarray< D3D12Pipe::ResourceData > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceData_Sg__sort(rdcarray< D3D12Pipe::ResourceData > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceData_Sg__copy(rdcarray< D3D12Pipe::ResourceData > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceData_Sg__reverse(rdcarray< D3D12Pipe::ResourceData > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceData_Sg__index(rdcarray< D3D12Pipe::ResourceData > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceData_Sg__count(rdcarray< D3D12Pipe::ResourceData > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceData_Sg__extend(rdcarray< D3D12Pipe::ResourceData > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceData_Sg__remove(rdcarray< D3D12Pipe::ResourceData > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<D3D12Pipe::ResourceData> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceState_Sg__append(rdcarray< D3D12Pipe::ResourceState > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceState_Sg__clear(rdcarray< D3D12Pipe::ResourceState > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceState_Sg__insert(rdcarray< D3D12Pipe::ResourceState > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceState_Sg__pop(rdcarray< D3D12Pipe::ResourceState > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceState_Sg__sort(rdcarray< D3D12Pipe::ResourceState > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceState_Sg__copy(rdcarray< D3D12Pipe::ResourceState > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceState_Sg__reverse(rdcarray< D3D12Pipe::ResourceState > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceState_Sg__index(rdcarray< D3D12Pipe::ResourceState > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceState_Sg__count(rdcarray< D3D12Pipe::ResourceState > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceState_Sg__extend(rdcarray< D3D12Pipe::ResourceState > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_ResourceState_Sg__remove(rdcarray< D3D12Pipe::ResourceState > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<D3D12Pipe::ResourceState> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__append(rdcarray< D3D12Pipe::StreamOutBind > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__clear(rdcarray< D3D12Pipe::StreamOutBind > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__insert(rdcarray< D3D12Pipe::StreamOutBind > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__pop(rdcarray< D3D12Pipe::StreamOutBind > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__sort(rdcarray< D3D12Pipe::StreamOutBind > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__copy(rdcarray< D3D12Pipe::StreamOutBind > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__reverse(rdcarray< D3D12Pipe::StreamOutBind > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__index(rdcarray< D3D12Pipe::StreamOutBind > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__count(rdcarray< D3D12Pipe::StreamOutBind > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__extend(rdcarray< D3D12Pipe::StreamOutBind > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__remove(rdcarray< D3D12Pipe::StreamOutBind > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<D3D12Pipe::StreamOutBind> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__append(rdcarray< D3D12Pipe::VertexBuffer > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__clear(rdcarray< D3D12Pipe::VertexBuffer > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__insert(rdcarray< D3D12Pipe::VertexBuffer > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__pop(rdcarray< D3D12Pipe::VertexBuffer > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__sort(rdcarray< D3D12Pipe::VertexBuffer > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__copy(rdcarray< D3D12Pipe::VertexBuffer > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__reverse(rdcarray< D3D12Pipe::VertexBuffer > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__index(rdcarray< D3D12Pipe::VertexBuffer > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__count(rdcarray< D3D12Pipe::VertexBuffer > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__extend(rdcarray< D3D12Pipe::VertexBuffer > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__remove(rdcarray< D3D12Pipe::VertexBuffer > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<D3D12Pipe::VertexBuffer> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__append(rdcarray< D3D12Pipe::RootTableRange > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__clear(rdcarray< D3D12Pipe::RootTableRange > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__insert(rdcarray< D3D12Pipe::RootTableRange > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__pop(rdcarray< D3D12Pipe::RootTableRange > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__sort(rdcarray< D3D12Pipe::RootTableRange > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__copy(rdcarray< D3D12Pipe::RootTableRange > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__reverse(rdcarray< D3D12Pipe::RootTableRange > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__index(rdcarray< D3D12Pipe::RootTableRange > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__count(rdcarray< D3D12Pipe::RootTableRange > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__extend(rdcarray< D3D12Pipe::RootTableRange > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__remove(rdcarray< D3D12Pipe::RootTableRange > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<D3D12Pipe::RootTableRange> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootParam_Sg__append(rdcarray< D3D12Pipe::RootParam > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootParam_Sg__clear(rdcarray< D3D12Pipe::RootParam > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootParam_Sg__insert(rdcarray< D3D12Pipe::RootParam > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootParam_Sg__pop(rdcarray< D3D12Pipe::RootParam > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootParam_Sg__sort(rdcarray< D3D12Pipe::RootParam > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootParam_Sg__copy(rdcarray< D3D12Pipe::RootParam > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootParam_Sg__reverse(rdcarray< D3D12Pipe::RootParam > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootParam_Sg__index(rdcarray< D3D12Pipe::RootParam > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootParam_Sg__count(rdcarray< D3D12Pipe::RootParam > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootParam_Sg__extend(rdcarray< D3D12Pipe::RootParam > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_RootParam_Sg__remove(rdcarray< D3D12Pipe::RootParam > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<D3D12Pipe::RootParam> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__append(rdcarray< D3D12Pipe::StaticSampler > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__clear(rdcarray< D3D12Pipe::StaticSampler > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__insert(rdcarray< D3D12Pipe::StaticSampler > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__pop(rdcarray< D3D12Pipe::StaticSampler > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__sort(rdcarray< D3D12Pipe::StaticSampler > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__copy(rdcarray< D3D12Pipe::StaticSampler > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__reverse(rdcarray< D3D12Pipe::StaticSampler > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__index(rdcarray< D3D12Pipe::StaticSampler > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__count(rdcarray< D3D12Pipe::StaticSampler > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__extend(rdcarray< D3D12Pipe::StaticSampler > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__remove(rdcarray< D3D12Pipe::StaticSampler > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<D3D12Pipe::StaticSampler> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexBuffer_Sg__append(rdcarray< GLPipe::VertexBuffer > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexBuffer_Sg__clear(rdcarray< GLPipe::VertexBuffer > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexBuffer_Sg__insert(rdcarray< GLPipe::VertexBuffer > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexBuffer_Sg__pop(rdcarray< GLPipe::VertexBuffer > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexBuffer_Sg__sort(rdcarray< GLPipe::VertexBuffer > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexBuffer_Sg__copy(rdcarray< GLPipe::VertexBuffer > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexBuffer_Sg__reverse(rdcarray< GLPipe::VertexBuffer > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexBuffer_Sg__index(rdcarray< GLPipe::VertexBuffer > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexBuffer_Sg__count(rdcarray< GLPipe::VertexBuffer > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexBuffer_Sg__extend(rdcarray< GLPipe::VertexBuffer > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexBuffer_Sg__remove(rdcarray< GLPipe::VertexBuffer > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<GLPipe::VertexBuffer> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexAttribute_Sg__append(rdcarray< GLPipe::VertexAttribute > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexAttribute_Sg__clear(rdcarray< GLPipe::VertexAttribute > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexAttribute_Sg__insert(rdcarray< GLPipe::VertexAttribute > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexAttribute_Sg__pop(rdcarray< GLPipe::VertexAttribute > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexAttribute_Sg__sort(rdcarray< GLPipe::VertexAttribute > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexAttribute_Sg__copy(rdcarray< GLPipe::VertexAttribute > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexAttribute_Sg__reverse(rdcarray< GLPipe::VertexAttribute > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexAttribute_Sg__index(rdcarray< GLPipe::VertexAttribute > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexAttribute_Sg__count(rdcarray< GLPipe::VertexAttribute > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexAttribute_Sg__extend(rdcarray< GLPipe::VertexAttribute > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_VertexAttribute_Sg__remove(rdcarray< GLPipe::VertexAttribute > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<GLPipe::VertexAttribute> *)
{
}


SWIGINTERN PyObject *rdcarray_Sl_GLPipe_TextureCompleteness_Sg__append(rdcarray< GLPipe::TextureCompleteness > *self,PyObject *value){
      return array_append(self, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_TextureCompleteness_Sg__clear(rdcarray< GLPipe::TextureCompleteness > *self){
      return array_clear(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_TextureCompleteness_Sg__insert(rdcarray< GLPipe::TextureCompleteness > *self,PyObject *index,PyObject *value){
      return array_insert(self, index, value);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_TextureCompleteness_Sg__pop(rdcarray< GLPipe::TextureCompleteness > *self,PyObject *index=NULL){
      return array_pop(self, index);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_TextureCompleteness_Sg__sort(rdcarray< GLPipe::TextureCompleteness > *self,PyObject *key=NULL,bool reverse=false){
      return array_sort(self, key, reverse);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_TextureCompleteness_Sg__copy(rdcarray< GLPipe::TextureCompleteness > *self){
      return array_copy(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_TextureCompleteness_Sg__reverse(rdcarray< GLPipe::TextureCompleteness > *self){
      return array_reverse(self);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_TextureCompleteness_Sg__index(rdcarray< GLPipe::TextureCompleteness > *self,PyObject *item,PyObject *start=NULL,PyObject *end=NULL){
      return array_indexOf(self, item, start, end);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_TextureCompleteness_Sg__count(rdcarray< GLPipe::TextureCompleteness > *self,PyObject *item){
      return array_countOf(self, item);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_TextureCompleteness_Sg__extend(rdcarray< GLPipe::TextureCompleteness > *self,PyObject *items){
      return array_selfconcat(self, items);
    }
SWIGINTERN PyObject *rdcarray_Sl_GLPipe_TextureCompleteness_Sg__remove(rdcarray< GLPipe::TextureCompleteness > *self,PyObject *item){
      return array_removeOne(self, item);
    }


template<>
void  add_your_use_of_rdcarray_to_swig_interface (rdcarray<GLPipe::TextureCompleteness> *)
{
}



  #include <set>
  #include "Code/pyrenderdoc/interface_check.h"

  // check interface, see interface_check.h for more information
  static swig_type_info **interfaceCheckTypes;
  static size_t interfaceCheckNumTypes = 0;

  bool CheckCoreInterface(rdcstr &log)
  {
#if defined(RELEASE)
    return false;
#else
    if(interfaceCheckNumTypes == 0)
      return false;

    return check_interface(log, interfaceCheckTypes, interfaceCheckNumTypes);
#endif
  }

#ifdef __cplusplus
extern "C" {
#endif

static PyObject *result_str(PyObject *resid)
{
  void *resptr = NULL;
  ResultDetails *result = NULL;
  int res = SWIG_ConvertPtr(resid, &resptr, SWIGTYPE_p_ResultDetails, 0);
  if (!SWIG_IsOK(res)) {
    SWIG_exception_fail(SWIG_ArgError(res), "in method 'ResultDetails.str', ResultDetails is not correct type");
  }

  result = (ResultDetails *)resptr;

  return PyUnicode_FromFormat("<Result: '%s'>", result->Message().c_str());
fail:
  return NULL;
}

static PyObject *resid_str(PyObject *resid)
{
  void *resptr = NULL;
  unsigned long long *id = NULL;
  int res = SWIG_ConvertPtr(resid, &resptr, SWIGTYPE_p_ResourceId, 0);
  if (!SWIG_IsOK(res)) {
    SWIG_exception_fail(SWIG_ArgError(res), "in method 'ResourceId.str', ResourceId is not correct type");
  }

  // cast as unsigned long long
  id = (unsigned long long *)resptr;
  static_assert(sizeof(unsigned long long) == sizeof(ResourceId), "Wrong size");

  return PyUnicode_FromFormat("ResourceId::%llu", *id);
fail:
  return NULL;
}

static Py_hash_t resid_hash(PyObject *resid)
{
  void *resptr = NULL;
  unsigned long long *id = NULL;
  int res = SWIG_ConvertPtr(resid, &resptr, SWIGTYPE_p_ResourceId, 0);
  if (!SWIG_IsOK(res)) {
    SWIG_exception_fail(SWIG_ArgError(res), "in method 'ResourceId.str', ResourceId is not correct type");
  }

  // cast as unsigned long long
  id = (unsigned long long *)resptr;
  static_assert(sizeof(unsigned long long) == sizeof(ResourceId), "Wrong size");

  return Py_hash_t(*id);
fail:
  return 0;
}

static PyObject *resid_int(PyObject *resid)
{
  void *resptr = NULL;
  unsigned long long *id = NULL;
  int res = SWIG_ConvertPtr(resid, &resptr, SWIGTYPE_p_ResourceId, 0);
  if (!SWIG_IsOK(res)) {
    SWIG_exception_fail(SWIG_ArgError(res), "in method 'ResourceId.str', ResourceId is not correct type");
  }

  // cast as unsigned long long
  id = (unsigned long long *)resptr;
  static_assert(sizeof(unsigned long long) == sizeof(ResourceId), "Wrong size");

  return PyLong_FromUnsignedLongLong(*id);
fail:
  return NULL;
}


// mostly identical to generated version, but registers with ExtRefcount
static int SDChunk_init(PyObject *self, PyObject *args)
{
  SDChunk *result = MakeFromArgsTuple<SDChunk>(args);

  if(!result)
    return -1;

  PyObject *resultobj = SWIG_NewPointerObj((void *)result, SWIGTYPE_p_SDChunk, SWIG_BUILTIN_INIT);

  if(Py_IsNone(resultobj))
  {
    delete result;
    return -1;
  }

  ExtRefcount<SDChunk *>::NewPyObject(resultobj, result);

  return 0;
}

static PyObject *SDChunk_dealloc(PyObject *self, PyObject *args)
{
  SDChunk *thisptr = NULL;

  int res = SWIG_ConvertPtr(self, (void **)&thisptr, SWIGTYPE_p_SDChunk, SWIG_POINTER_DISOWN);
  if(!SWIG_IsOK(res))
    SWIG_exception_fail(SWIG_ArgError(res), "Invalid ""SDChunk" " being deleted");

  ExtRefcount<SDChunk *>::DelPyObject(self, thisptr);
  delete thisptr;

  return SWIG_Py_Void();
fail:
  return NULL;
}

SWIGPY_DESTRUCTOR_CLOSURE(SDChunk_dealloc)



// mostly identical to generated version, but registers with ExtRefcount
static int SDObject_init(PyObject *self, PyObject *args)
{
  SDObject *result = MakeFromArgsTuple<SDObject>(args);

  if(!result)
    return -1;

  PyObject *resultobj = SWIG_NewPointerObj((void *)result, SWIGTYPE_p_SDObject, SWIG_BUILTIN_INIT);

  if(Py_IsNone(resultobj))
  {
    delete result;
    return -1;
  }

  ExtRefcount<SDObject *>::NewPyObject(resultobj, result);

  return 0;
}

static PyObject *SDObject_dealloc(PyObject *self, PyObject *args)
{
  SDObject *thisptr = NULL;

  int res = SWIG_ConvertPtr(self, (void **)&thisptr, SWIGTYPE_p_SDObject, SWIG_POINTER_DISOWN);
  if(!SWIG_IsOK(res))
    SWIG_exception_fail(SWIG_ArgError(res), "Invalid ""SDObject" " being deleted");

  ExtRefcount<SDObject *>::DelPyObject(self, thisptr);
  delete thisptr;

  return SWIG_Py_Void();
fail:
  return NULL;
}

SWIGPY_DESTRUCTOR_CLOSURE(SDObject_dealloc)



// mostly identical to generated version, but registers with ExtRefcount
static int SDFile_init(PyObject *self, PyObject *args)
{
  SDFile *result = MakeFromArgsTuple<SDFile>(args);

  if(!result)
    return -1;

  PyObject *resultobj = SWIG_NewPointerObj((void *)result, SWIGTYPE_p_SDFile, SWIG_BUILTIN_INIT);

  if(Py_IsNone(resultobj))
  {
    delete result;
    return -1;
  }

  ExtRefcount<SDFile *>::NewPyObject(resultobj, result);

  return 0;
}

static PyObject *SDFile_dealloc(PyObject *self, PyObject *args)
{
  SDFile *thisptr = NULL;

  int res = SWIG_ConvertPtr(self, (void **)&thisptr, SWIGTYPE_p_SDFile, SWIG_POINTER_DISOWN);
  if(!SWIG_IsOK(res))
    SWIG_exception_fail(SWIG_ArgError(res), "Invalid ""SDFile" " being deleted");

  ExtRefcount<SDFile *>::DelPyObject(self, thisptr);
  delete thisptr;

  return SWIG_Py_Void();
fail:
  return NULL;
}

SWIGPY_DESTRUCTOR_CLOSURE(SDFile_dealloc)



PyObject *repr_StructuredChunkList(PyObject *self)
{
  StructuredChunkList *thisptr = array_thisptr<StructuredChunkList>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_StructuredChunkList(PyObject *self, Py_ssize_t idx)
{
  StructuredChunkList *thisptr = array_thisptr<StructuredChunkList>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_StructuredChunkList(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  StructuredChunkList *thisptr = array_thisptr<StructuredChunkList>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_StructuredChunkList(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  StructuredChunkList *thisptr = array_thisptr<StructuredChunkList>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_StructuredChunkList(PyObject *self, PyObject *idx)
{
  StructuredChunkList *thisptr = array_thisptr<StructuredChunkList>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_StructuredChunkList(PyObject *self, PyObject *idx, PyObject *val)
{
  StructuredChunkList *thisptr = array_thisptr<StructuredChunkList>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_StructuredChunkList(PyObject *self, PyObject *vals)
{
  StructuredChunkList *thisptr = array_thisptr<StructuredChunkList>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_StructuredChunkList(PyObject *self, Py_ssize_t count)
{
  StructuredChunkList *thisptr = array_thisptr<StructuredChunkList>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_StructuredChunkList(PyObject *self, PyObject *vals)
{
  StructuredChunkList *thisptr = array_thisptr<StructuredChunkList>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_StructuredChunkList(PyObject *self, Py_ssize_t count)
{
  StructuredChunkList *thisptr = array_thisptr<StructuredChunkList>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}


PyObject *repr_StructuredObjectList(PyObject *self)
{
  StructuredObjectList *thisptr = array_thisptr<StructuredObjectList>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_StructuredObjectList(PyObject *self, Py_ssize_t idx)
{
  StructuredObjectList *thisptr = array_thisptr<StructuredObjectList>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_StructuredObjectList(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  StructuredObjectList *thisptr = array_thisptr<StructuredObjectList>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_StructuredObjectList(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  StructuredObjectList *thisptr = array_thisptr<StructuredObjectList>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_StructuredObjectList(PyObject *self, PyObject *idx)
{
  StructuredObjectList *thisptr = array_thisptr<StructuredObjectList>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_StructuredObjectList(PyObject *self, PyObject *idx, PyObject *val)
{
  StructuredObjectList *thisptr = array_thisptr<StructuredObjectList>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_StructuredObjectList(PyObject *self, PyObject *vals)
{
  StructuredObjectList *thisptr = array_thisptr<StructuredObjectList>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_StructuredObjectList(PyObject *self, Py_ssize_t count)
{
  StructuredObjectList *thisptr = array_thisptr<StructuredObjectList>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_StructuredObjectList(PyObject *self, PyObject *vals)
{
  StructuredObjectList *thisptr = array_thisptr<StructuredObjectList>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_StructuredObjectList(PyObject *self, Py_ssize_t count)
{
  StructuredObjectList *thisptr = array_thisptr<StructuredObjectList>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}


PyObject *repr_StructuredBufferList(PyObject *self)
{
  StructuredBufferList *thisptr = array_thisptr<StructuredBufferList>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_StructuredBufferList(PyObject *self, Py_ssize_t idx)
{
  StructuredBufferList *thisptr = array_thisptr<StructuredBufferList>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_StructuredBufferList(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  StructuredBufferList *thisptr = array_thisptr<StructuredBufferList>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_StructuredBufferList(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  StructuredBufferList *thisptr = array_thisptr<StructuredBufferList>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_StructuredBufferList(PyObject *self, PyObject *idx)
{
  StructuredBufferList *thisptr = array_thisptr<StructuredBufferList>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_StructuredBufferList(PyObject *self, PyObject *idx, PyObject *val)
{
  StructuredBufferList *thisptr = array_thisptr<StructuredBufferList>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_StructuredBufferList(PyObject *self, PyObject *vals)
{
  StructuredBufferList *thisptr = array_thisptr<StructuredBufferList>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_StructuredBufferList(PyObject *self, Py_ssize_t count)
{
  StructuredBufferList *thisptr = array_thisptr<StructuredBufferList>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_StructuredBufferList(PyObject *self, PyObject *vals)
{
  StructuredBufferList *thisptr = array_thisptr<StructuredBufferList>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_StructuredBufferList(PyObject *self, Py_ssize_t count)
{
  StructuredBufferList *thisptr = array_thisptr<StructuredBufferList>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_CreateHeadlessWindowingData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int32_t arg1 ;
  int32_t arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  WindowingData result;
  
  if (!SWIG_Python_UnpackTuple(args,"CreateHeadlessWindowingData",2,2,swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CreateHeadlessWindowingData" "', argument " "1"" of type '" "int32_t""'");
  } 
  arg1 = static_cast< int32_t >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateHeadlessWindowingData" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  result = CreateHeadlessWindowingData(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new WindowingData(static_cast< const WindowingData& >(result))), SWIGTYPE_p_WindowingData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreateWin32WindowingData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HWND arg1 = (HWND) 0 ;
  unsigned long long tmp1 ;
  int err1 = 0 ;
  PyObject *swig_obj[1] ;
  WindowingData result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    // convert windowing data pointers from just plain integers
    err1 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[0], &tmp1);
    if (!SWIG_IsOK(err1)) {
      SWIG_exception_fail(SWIG_ArgError(err1), "in method '" "CreateWin32WindowingData" "', argument " "1"" of type '" "HWND__""'");
    } 
    arg1 = (HWND)tmp1;
  }
  result = CreateWin32WindowingData(arg1);
  resultobj = SWIG_NewPointerObj((new WindowingData(static_cast< const WindowingData& >(result))), SWIGTYPE_p_WindowingData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreateXlibWindowingData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Display *arg1 = (Display *) 0 ;
  Drawable arg2 ;
  unsigned long long tmp1 ;
  int err1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  WindowingData result;
  
  if (!SWIG_Python_UnpackTuple(args,"CreateXlibWindowingData",2,2,swig_obj)) SWIG_fail;
  {
    // convert windowing data pointers from just plain integers
    err1 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[0], &tmp1);
    if (!SWIG_IsOK(err1)) {
      SWIG_exception_fail(SWIG_ArgError(err1), "in method '" "CreateXlibWindowingData" "', argument " "1"" of type '" "Display""'");
    } 
    arg1 = (Display *)tmp1;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateXlibWindowingData" "', argument " "2"" of type '" "Drawable""'");
  } 
  arg2 = static_cast< Drawable >(val2);
  result = CreateXlibWindowingData(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new WindowingData(static_cast< const WindowingData& >(result))), SWIGTYPE_p_WindowingData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreateXCBWindowingData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  xcb_connection_t *arg1 = (xcb_connection_t *) 0 ;
  xcb_window_t arg2 ;
  unsigned long long tmp1 ;
  int err1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  WindowingData result;
  
  if (!SWIG_Python_UnpackTuple(args,"CreateXCBWindowingData",2,2,swig_obj)) SWIG_fail;
  {
    // convert windowing data pointers from just plain integers
    err1 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[0], &tmp1);
    if (!SWIG_IsOK(err1)) {
      SWIG_exception_fail(SWIG_ArgError(err1), "in method '" "CreateXCBWindowingData" "', argument " "1"" of type '" "xcb_connection_t""'");
    } 
    arg1 = (xcb_connection_t *)tmp1;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateXCBWindowingData" "', argument " "2"" of type '" "xcb_window_t""'");
  } 
  arg2 = static_cast< xcb_window_t >(val2);
  result = CreateXCBWindowingData(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new WindowingData(static_cast< const WindowingData& >(result))), SWIGTYPE_p_WindowingData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreateWaylandWindowingData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  wl_display *arg1 = (wl_display *) 0 ;
  wl_surface *arg2 = (wl_surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long tmp2 ;
  int err2 = 0 ;
  PyObject *swig_obj[2] ;
  WindowingData result;
  
  if (!SWIG_Python_UnpackTuple(args,"CreateWaylandWindowingData",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wl_display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateWaylandWindowingData" "', argument " "1"" of type '" "wl_display *""'"); 
  }
  arg1 = reinterpret_cast< wl_display * >(argp1);
  {
    // convert windowing data pointers from just plain integers
    err2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &tmp2);
    if (!SWIG_IsOK(err2)) {
      SWIG_exception_fail(SWIG_ArgError(err2), "in method '" "CreateWaylandWindowingData" "', argument " "2"" of type '" "wl_surface""'");
    } 
    arg2 = (wl_surface *)tmp2;
  }
  result = CreateWaylandWindowingData(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new WindowingData(static_cast< const WindowingData& >(result))), SWIGTYPE_p_WindowingData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreateAndroidWindowingData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ANativeWindow *arg1 = (ANativeWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  WindowingData result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ANativeWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateAndroidWindowingData" "', argument " "1"" of type '" "ANativeWindow *""'"); 
  }
  arg1 = reinterpret_cast< ANativeWindow * >(argp1);
  result = CreateAndroidWindowingData(arg1);
  resultobj = SWIG_NewPointerObj((new WindowingData(static_cast< const WindowingData& >(result))), SWIGTYPE_p_WindowingData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreateMacOSWindowingData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NSView arg1 = (NSView) 0 ;
  CALayer arg2 = (CALayer) 0 ;
  int res1 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  WindowingData result;
  
  if (!SWIG_Python_UnpackTuple(args,"CreateMacOSWindowingData",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateMacOSWindowingData" "', argument " "1"" of type '" "NSView""'"); 
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateMacOSWindowingData" "', argument " "2"" of type '" "CALayer""'"); 
  }
  result = CreateMacOSWindowingData(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new WindowingData(static_cast< const WindowingData& >(result))), SWIGTYPE_p_WindowingData, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_Shutdown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOutput_Shutdown",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_Shutdown" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  (arg1)->Shutdown();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_SetTextureDisplay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  TextureDisplay *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_SetTextureDisplay" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_TextureDisplay,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayOutput_SetTextureDisplay" "', argument " "2"" of type '" "TextureDisplay const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayOutput_SetTextureDisplay" "', argument " "2"" of type '" "TextureDisplay const &""'"); 
  }
  arg2 = reinterpret_cast< TextureDisplay * >(argp2);
  (arg1)->SetTextureDisplay((TextureDisplay const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_SetMeshDisplay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  MeshDisplay *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_SetMeshDisplay" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_MeshDisplay,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayOutput_SetMeshDisplay" "', argument " "2"" of type '" "MeshDisplay const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayOutput_SetMeshDisplay" "', argument " "2"" of type '" "MeshDisplay const &""'"); 
  }
  arg2 = reinterpret_cast< MeshDisplay * >(argp2);
  (arg1)->SetMeshDisplay((MeshDisplay const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_ReadbackOutputTexture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bytebuf result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOutput_ReadbackOutputTexture",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_ReadbackOutputTexture" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  result = (arg1)->ReadbackOutputTexture();
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_GetDimensions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcpair< int32_t,int32_t > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOutput_GetDimensions",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_GetDimensions" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  result = (arg1)->GetDimensions();
  {
    resultobj = ConvertToPy((rdcpair< int32_t,int32_t >&)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_ClearThumbnails(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOutput_ClearThumbnails",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_ClearThumbnails" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  (arg1)->ClearThumbnails();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_AddThumbnail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  WindowingData arg2 ;
  ResourceId arg3 ;
  Subresource *arg4 = 0 ;
  CompType arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  ResultDetails result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOutput_AddThumbnail",4,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_AddThumbnail" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_WindowingData,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayOutput_AddThumbnail" "', argument " "2"" of type '" "WindowingData""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayOutput_AddThumbnail" "', argument " "2"" of type '" "WindowingData""'");
    } else {
      WindowingData * temp = reinterpret_cast< WindowingData * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ReplayOutput_AddThumbnail" "', argument " "3"" of type '" "ResourceId""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayOutput_AddThumbnail" "', argument " "3"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4, SWIGTYPE_p_Subresource,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ReplayOutput_AddThumbnail" "', argument " "4"" of type '" "Subresource const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayOutput_AddThumbnail" "', argument " "4"" of type '" "Subresource const &""'"); 
  }
  arg4 = reinterpret_cast< Subresource * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ReplayOutput_AddThumbnail" "', argument " "5"" of type '" "CompType""'");
  } 
  arg5 = static_cast< CompType >(val5);
  result = (arg1)->AddThumbnail(arg2,arg3,(Subresource const &)*arg4,arg5);
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_DrawThumbnail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  ResourceId arg4 ;
  Subresource *arg5 = 0 ;
  CompType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  bytebuf result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOutput_DrawThumbnail",5,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_DrawThumbnail" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReplayOutput_DrawThumbnail" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReplayOutput_DrawThumbnail" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[2], &argp4, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ReplayOutput_DrawThumbnail" "', argument " "4"" of type '" "ResourceId""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayOutput_DrawThumbnail" "', argument " "4"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[3], &argp5, SWIGTYPE_p_Subresource,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ReplayOutput_DrawThumbnail" "', argument " "5"" of type '" "Subresource const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayOutput_DrawThumbnail" "', argument " "5"" of type '" "Subresource const &""'"); 
  }
  arg5 = reinterpret_cast< Subresource * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ReplayOutput_DrawThumbnail" "', argument " "6"" of type '" "CompType""'");
  } 
  arg6 = static_cast< CompType >(val6);
  result = (arg1)->DrawThumbnail(arg2,arg3,arg4,(Subresource const &)*arg5,arg6);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_Display(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOutput_Display",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_Display" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  (arg1)->Display();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_SetPixelContext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  WindowingData arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ResultDetails result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_SetPixelContext" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_WindowingData,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayOutput_SetPixelContext" "', argument " "2"" of type '" "WindowingData""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayOutput_SetPixelContext" "', argument " "2"" of type '" "WindowingData""'");
    } else {
      WindowingData * temp = reinterpret_cast< WindowingData * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (arg1)->SetPixelContext(arg2);
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_SetPixelContextLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOutput_SetPixelContextLocation",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_SetPixelContextLocation" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReplayOutput_SetPixelContextLocation" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReplayOutput_SetPixelContextLocation" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  (arg1)->SetPixelContextLocation(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_DisablePixelContext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOutput_DisablePixelContext",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_DisablePixelContext" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  (arg1)->DisablePixelContext();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_GetCustomShaderTexID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOutput_GetCustomShaderTexID",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_GetCustomShaderTexID" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  result = (arg1)->GetCustomShaderTexID();
  resultobj = SWIG_NewPointerObj((new ResourceId(static_cast< const ResourceId& >(result))), SWIGTYPE_p_ResourceId, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_GetDebugOverlayTexID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOutput_GetDebugOverlayTexID",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_GetDebugOverlayTexID" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  result = (arg1)->GetDebugOverlayTexID();
  resultobj = SWIG_NewPointerObj((new ResourceId(static_cast< const ResourceId& >(result))), SWIGTYPE_p_ResourceId, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOutput_PickVertex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayOutput *arg1 = (IReplayOutput *) 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  rdcpair< uint32_t,uint32_t > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOutput_PickVertex",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOutput_PickVertex" "', argument " "1"" of type '" "IReplayOutput *""'"); 
  }
  arg1 = reinterpret_cast< IReplayOutput * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReplayOutput_PickVertex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReplayOutput_PickVertex" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  result = (arg1)->PickVertex(arg2,arg3);
  {
    resultobj = ConvertToPy((rdcpair< uint32_t,uint32_t >&)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetAPIProperties(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  APIProperties result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetAPIProperties",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetAPIProperties" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (arg1)->GetAPIProperties();
  resultobj = SWIG_NewPointerObj((new APIProperties(static_cast< const APIProperties& >(result))), SWIGTYPE_p_APIProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetSupportedWindowSystems(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< WindowingSystem > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetSupportedWindowSystems",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetSupportedWindowSystems" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (arg1)->GetSupportedWindowSystems();
  resultobj = SWIG_NewPointerObj((new rdcarray< WindowingSystem >(static_cast< const rdcarray< WindowingSystem >& >(result))), SWIGTYPE_p_rdcarrayT_WindowingSystem_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_CreateOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  WindowingData arg2 ;
  ReplayOutputType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  IReplayOutput *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_CreateOutput",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_CreateOutput" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_WindowingData,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_CreateOutput" "', argument " "2"" of type '" "WindowingData""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_CreateOutput" "', argument " "2"" of type '" "WindowingData""'");
    } else {
      WindowingData * temp = reinterpret_cast< WindowingData * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReplayController_CreateOutput" "', argument " "3"" of type '" "ReplayOutputType""'");
  } 
  arg3 = static_cast< ReplayOutputType >(val3);
  result = (IReplayOutput *)(arg1)->CreateOutput(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IReplayOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_Shutdown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_Shutdown",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_Shutdown" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  (arg1)->Shutdown();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_ReplayLoop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  WindowingData arg2 ;
  ResourceId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_ReplayLoop",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_ReplayLoop" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_WindowingData,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_ReplayLoop" "', argument " "2"" of type '" "WindowingData""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_ReplayLoop" "', argument " "2"" of type '" "WindowingData""'");
    } else {
      WindowingData * temp = reinterpret_cast< WindowingData * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ReplayController_ReplayLoop" "', argument " "3"" of type '" "ResourceId""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_ReplayLoop" "', argument " "3"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->ReplayLoop(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_CreateRGPProfile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  WindowingData arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  rdcstr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_CreateRGPProfile" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_WindowingData,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_CreateRGPProfile" "', argument " "2"" of type '" "WindowingData""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_CreateRGPProfile" "', argument " "2"" of type '" "WindowingData""'");
    } else {
      WindowingData * temp = reinterpret_cast< WindowingData * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (arg1)->CreateRGPProfile(arg2);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_CancelReplayLoop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_CancelReplayLoop",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_CancelReplayLoop" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  (arg1)->CancelReplayLoop();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_FileChanged(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_FileChanged",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_FileChanged" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  (arg1)->FileChanged();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_SetFrameEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  uint32_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_SetFrameEvent",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_SetFrameEvent" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReplayController_SetFrameEvent" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReplayController_SetFrameEvent" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->SetFrameEvent(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetD3D11PipelineState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::State *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetD3D11PipelineState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetD3D11PipelineState" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (D3D11Pipe::State *)(arg1)->GetD3D11PipelineState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetD3D12PipelineState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::State *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetD3D12PipelineState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetD3D12PipelineState" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (D3D12Pipe::State *)(arg1)->GetD3D12PipelineState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetGLPipelineState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::State *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetGLPipelineState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetGLPipelineState" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (GLPipe::State *)(arg1)->GetGLPipelineState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__State, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetVulkanPipelineState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::State *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetVulkanPipelineState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetVulkanPipelineState" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (VKPipe::State *)(arg1)->GetVulkanPipelineState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__State, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetPipelineState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PipeState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetPipelineState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetPipelineState" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (PipeState *) &(arg1)->GetPipelineState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PipeState, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetDescriptors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  rdcarray< DescriptorRange > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned char tempmem3[32] ;
  bool wasSelf3 = false ;
  PyObject *swig_obj[3] ;
  rdcarray< Descriptor > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetDescriptors",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetDescriptors" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_GetDescriptors" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetDescriptors" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg3)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem3) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg3, tempmem3);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[1], indirect(arg3), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_GetDescriptors' argument 3 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ReplayController_GetDescriptors' argument 3 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg3); 
  }
  result = (arg1)->GetDescriptors(arg2,(rdcarray< DescriptorRange > const &)*arg3);
  resultobj = SWIG_NewPointerObj((new rdcarray< Descriptor >(static_cast< const rdcarray< Descriptor >& >(result))), SWIGTYPE_p_rdcarrayT_Descriptor_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetSamplerDescriptors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  rdcarray< DescriptorRange > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned char tempmem3[32] ;
  bool wasSelf3 = false ;
  PyObject *swig_obj[3] ;
  rdcarray< SamplerDescriptor > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetSamplerDescriptors",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetSamplerDescriptors" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_GetSamplerDescriptors" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetSamplerDescriptors" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg3)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem3) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg3, tempmem3);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[1], indirect(arg3), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_GetSamplerDescriptors' argument 3 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ReplayController_GetSamplerDescriptors' argument 3 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg3); 
  }
  result = (arg1)->GetSamplerDescriptors(arg2,(rdcarray< DescriptorRange > const &)*arg3);
  resultobj = SWIG_NewPointerObj((new rdcarray< SamplerDescriptor >(static_cast< const rdcarray< SamplerDescriptor >& >(result))), SWIGTYPE_p_rdcarrayT_SamplerDescriptor_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetDescriptorAccess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< DescriptorAccess > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetDescriptorAccess",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetDescriptorAccess" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (rdcarray< DescriptorAccess > *) &(arg1)->GetDescriptorAccess();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_DescriptorAccess_t, 0 |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetDescriptorLocations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  rdcarray< DescriptorRange > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned char tempmem3[32] ;
  bool wasSelf3 = false ;
  PyObject *swig_obj[3] ;
  rdcarray< DescriptorLogicalLocation > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetDescriptorLocations",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetDescriptorLocations" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_GetDescriptorLocations" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetDescriptorLocations" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg3)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem3) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg3, tempmem3);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[1], indirect(arg3), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_GetDescriptorLocations' argument 3 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ReplayController_GetDescriptorLocations' argument 3 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg3); 
  }
  result = (arg1)->GetDescriptorLocations(arg2,(rdcarray< DescriptorRange > const &)*arg3);
  resultobj = SWIG_NewPointerObj((new rdcarray< DescriptorLogicalLocation >(static_cast< const rdcarray< DescriptorLogicalLocation >& >(result))), SWIGTYPE_p_rdcarrayT_DescriptorLogicalLocation_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetDisassemblyTargets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  rdcarray< rdcstr > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetDisassemblyTargets" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReplayController_GetDisassemblyTargets" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (arg1)->GetDisassemblyTargets(arg2);
  resultobj = SWIG_NewPointerObj((new rdcarray< rdcstr >(static_cast< const rdcarray< rdcstr >& >(result))), SWIGTYPE_p_rdcarrayT_rdcstr_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_DisassembleShader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  ShaderReflection *arg3 = (ShaderReflection *) 0 ;
  rdcstr *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  rdcstr temp4 ;
  PyObject *swig_obj[4] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_DisassembleShader",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_DisassembleShader" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_DisassembleShader" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_DisassembleShader" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ReplayController_DisassembleShader" "', argument " "3"" of type '" "ShaderReflection const *""'"); 
  }
  arg3 = reinterpret_cast< ShaderReflection * >(argp3);
  {
    tempset(arg4, &temp4);
    
    int res = ConvertFromPy(swig_obj[2], indirect(arg4));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_DisassembleShader' argument 4 of type 'rdcstr'"); 
    }
  }
  result = (arg1)->DisassembleShader(arg2,(ShaderReflection const *)arg3,(rdcstr const &)*arg4);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_SetCustomShaderIncludes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  rdcarray< rdcstr > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_SetCustomShaderIncludes" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_SetCustomShaderIncludes' argument 2 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ReplayController_SetCustomShaderIncludes' argument 2 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  (arg1)->SetCustomShaderIncludes((rdcarray< rdcstr > const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_BuildCustomShader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  rdcstr *arg2 = 0 ;
  ShaderEncoding arg3 ;
  bytebuf arg4 ;
  ShaderCompileFlags *arg5 = 0 ;
  ShaderStage arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  bytebuf temp4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  rdcpair< ResourceId,rdcstr > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_BuildCustomShader",5,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_BuildCustomShader" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_BuildCustomShader' argument 2 of type 'rdcstr'"); 
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReplayController_BuildCustomShader" "', argument " "3"" of type '" "ShaderEncoding""'");
  } 
  arg3 = static_cast< ShaderEncoding >(val3);
  {
    tempset(arg4, &temp4);
    
    int res = ConvertFromPy(swig_obj[2], indirect(arg4));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_BuildCustomShader' argument 4 of type 'bytebuf'"); 
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[3], &argp5, SWIGTYPE_p_ShaderCompileFlags,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ReplayController_BuildCustomShader" "', argument " "5"" of type '" "ShaderCompileFlags const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_BuildCustomShader" "', argument " "5"" of type '" "ShaderCompileFlags const &""'"); 
  }
  arg5 = reinterpret_cast< ShaderCompileFlags * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ReplayController_BuildCustomShader" "', argument " "6"" of type '" "ShaderStage""'");
  } 
  arg6 = static_cast< ShaderStage >(val6);
  result = (arg1)->BuildCustomShader((rdcstr const &)*arg2,arg3,arg4,(ShaderCompileFlags const &)*arg5,arg6);
  {
    resultobj = ConvertToPy((rdcpair< ResourceId,rdcstr >&)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_FreeCustomShader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_FreeCustomShader" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_FreeCustomShader" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_FreeCustomShader" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->FreeCustomShader(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_BuildTargetShader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  rdcstr *arg2 = 0 ;
  ShaderEncoding arg3 ;
  bytebuf arg4 ;
  ShaderCompileFlags *arg5 = 0 ;
  ShaderStage arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  bytebuf temp4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  rdcpair< ResourceId,rdcstr > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_BuildTargetShader",5,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_BuildTargetShader" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_BuildTargetShader' argument 2 of type 'rdcstr'"); 
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReplayController_BuildTargetShader" "', argument " "3"" of type '" "ShaderEncoding""'");
  } 
  arg3 = static_cast< ShaderEncoding >(val3);
  {
    tempset(arg4, &temp4);
    
    int res = ConvertFromPy(swig_obj[2], indirect(arg4));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_BuildTargetShader' argument 4 of type 'bytebuf'"); 
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[3], &argp5, SWIGTYPE_p_ShaderCompileFlags,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ReplayController_BuildTargetShader" "', argument " "5"" of type '" "ShaderCompileFlags const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_BuildTargetShader" "', argument " "5"" of type '" "ShaderCompileFlags const &""'"); 
  }
  arg5 = reinterpret_cast< ShaderCompileFlags * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ReplayController_BuildTargetShader" "', argument " "6"" of type '" "ShaderStage""'");
  } 
  arg6 = static_cast< ShaderStage >(val6);
  result = (arg1)->BuildTargetShader((rdcstr const &)*arg2,arg3,arg4,(ShaderCompileFlags const &)*arg5,arg6);
  {
    resultobj = ConvertToPy((rdcpair< ResourceId,rdcstr >&)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetTargetShaderEncodings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderEncoding > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetTargetShaderEncodings",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetTargetShaderEncodings" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (arg1)->GetTargetShaderEncodings();
  resultobj = SWIG_NewPointerObj((new rdcarray< ShaderEncoding >(static_cast< const rdcarray< ShaderEncoding >& >(result))), SWIGTYPE_p_rdcarrayT_ShaderEncoding_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetCustomShaderEncodings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderEncoding > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetCustomShaderEncodings",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetCustomShaderEncodings" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (arg1)->GetCustomShaderEncodings();
  resultobj = SWIG_NewPointerObj((new rdcarray< ShaderEncoding >(static_cast< const rdcarray< ShaderEncoding >& >(result))), SWIGTYPE_p_rdcarrayT_ShaderEncoding_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetCustomShaderSourcePrefixes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderSourcePrefix > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetCustomShaderSourcePrefixes",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetCustomShaderSourcePrefixes" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (arg1)->GetCustomShaderSourcePrefixes();
  resultobj = SWIG_NewPointerObj((new rdcarray< ShaderSourcePrefix >(static_cast< const rdcarray< ShaderSourcePrefix >& >(result))), SWIGTYPE_p_rdcarrayT_ShaderSourcePrefix_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_ReplaceResource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  ResourceId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_ReplaceResource",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_ReplaceResource" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_ReplaceResource" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_ReplaceResource" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ReplayController_ReplaceResource" "', argument " "3"" of type '" "ResourceId""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_ReplaceResource" "', argument " "3"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->ReplaceResource(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_ClearReplayCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_ClearReplayCache",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_ClearReplayCache" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  (arg1)->ClearReplayCache();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_ReloadShaderDebugInformation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_ReloadShaderDebugInformation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_ReloadShaderDebugInformation" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  (arg1)->ReloadShaderDebugInformation();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_RemoveReplacement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_RemoveReplacement" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_RemoveReplacement" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_RemoveReplacement" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->RemoveReplacement(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_FreeTargetResource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_FreeTargetResource" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_FreeTargetResource" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_FreeTargetResource" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->FreeTargetResource(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetFrameInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FrameDescription result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetFrameInfo",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetFrameInfo" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (arg1)->GetFrameInfo();
  resultobj = SWIG_NewPointerObj((new FrameDescription(static_cast< const FrameDescription& >(result))), SWIGTYPE_p_FrameDescription, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetStructuredFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDFile *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetStructuredFile",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetStructuredFile" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (SDFile *) &(arg1)->GetStructuredFile();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDFile, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_AddFakeMarkers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_AddFakeMarkers",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_AddFakeMarkers" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  (arg1)->AddFakeMarkers();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetRootActions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ActionDescription > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetRootActions",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetRootActions" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (rdcarray< ActionDescription > *) &(arg1)->GetRootActions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ActionDescription_t, 0 |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_FetchCounters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  rdcarray< GPUCounter > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  rdcarray< CounterResult > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_FetchCounters" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_FetchCounters' argument 2 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ReplayController_FetchCounters' argument 2 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (arg1)->FetchCounters((rdcarray< GPUCounter > const &)*arg2);
  resultobj = SWIG_NewPointerObj((new rdcarray< CounterResult >(static_cast< const rdcarray< CounterResult >& >(result))), SWIGTYPE_p_rdcarrayT_CounterResult_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_EnumerateCounters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< GPUCounter > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_EnumerateCounters",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_EnumerateCounters" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (arg1)->EnumerateCounters();
  resultobj = SWIG_NewPointerObj((new rdcarray< GPUCounter >(static_cast< const rdcarray< GPUCounter >& >(result))), SWIGTYPE_p_rdcarrayT_GPUCounter_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_DescribeCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  GPUCounter arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  CounterDescription result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_DescribeCounter" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReplayController_DescribeCounter" "', argument " "2"" of type '" "GPUCounter""'");
  } 
  arg2 = static_cast< GPUCounter >(val2);
  result = (arg1)->DescribeCounter(arg2);
  resultobj = SWIG_NewPointerObj((new CounterDescription(static_cast< const CounterDescription& >(result))), SWIGTYPE_p_CounterDescription, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetResources(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ResourceDescription > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetResources",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetResources" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (rdcarray< ResourceDescription > *) &(arg1)->GetResources();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ResourceDescription_t, 0 |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetTextures(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< TextureDescription > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetTextures",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetTextures" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (rdcarray< TextureDescription > *) &(arg1)->GetTextures();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_TextureDescription_t, 0 |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetBuffers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< BufferDescription > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetBuffers",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetBuffers" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (rdcarray< BufferDescription > *) &(arg1)->GetBuffers();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_BufferDescription_t, 0 |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetDescriptorStores(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< DescriptorStoreDescription > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetDescriptorStores",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetDescriptorStores" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (rdcarray< DescriptorStoreDescription > *) &(arg1)->GetDescriptorStores();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_DescriptorStoreDescription_t, 0 |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetDebugMessages(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< DebugMessage > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetDebugMessages",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetDebugMessages" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (arg1)->GetDebugMessages();
  resultobj = SWIG_NewPointerObj((new rdcarray< DebugMessage >(static_cast< const rdcarray< DebugMessage >& >(result))), SWIGTYPE_p_rdcarrayT_DebugMessage_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetFatalErrorStatus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResultDetails result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetFatalErrorStatus",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetFatalErrorStatus" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  result = (arg1)->GetFatalErrorStatus();
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetShaderEntryPoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  rdcarray< ShaderEntryPoint > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetShaderEntryPoints" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_GetShaderEntryPoints" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetShaderEntryPoints" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (arg1)->GetShaderEntryPoints(arg2);
  resultobj = SWIG_NewPointerObj((new rdcarray< ShaderEntryPoint >(static_cast< const rdcarray< ShaderEntryPoint >& >(result))), SWIGTYPE_p_rdcarrayT_ShaderEntryPoint_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetShader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  ResourceId arg3 ;
  ShaderEntryPoint arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  ShaderReflection *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetShader",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetShader" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_GetShader" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetShader" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ReplayController_GetShader" "', argument " "3"" of type '" "ResourceId""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetShader" "', argument " "3"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[2], &argp4, SWIGTYPE_p_ShaderEntryPoint,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ReplayController_GetShader" "', argument " "4"" of type '" "ShaderEntryPoint""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetShader" "', argument " "4"" of type '" "ShaderEntryPoint""'");
    } else {
      ShaderEntryPoint * temp = reinterpret_cast< ShaderEntryPoint * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  result = (ShaderReflection *)(arg1)->GetShader(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderReflection, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_PickPixel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  Subresource *arg5 = 0 ;
  CompType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  PixelValue result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_PickPixel",5,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_PickPixel" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_PickPixel" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_PickPixel" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReplayController_PickPixel" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ReplayController_PickPixel" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[3], &argp5, SWIGTYPE_p_Subresource,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ReplayController_PickPixel" "', argument " "5"" of type '" "Subresource const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_PickPixel" "', argument " "5"" of type '" "Subresource const &""'"); 
  }
  arg5 = reinterpret_cast< Subresource * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ReplayController_PickPixel" "', argument " "6"" of type '" "CompType""'");
  } 
  arg6 = static_cast< CompType >(val6);
  result = (arg1)->PickPixel(arg2,arg3,arg4,(Subresource const &)*arg5,arg6);
  resultobj = SWIG_NewPointerObj((new PixelValue(static_cast< const PixelValue& >(result))), SWIGTYPE_p_PixelValue, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetMinMax(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  Subresource *arg3 = 0 ;
  CompType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  SwigValueWrapper< rdcpair< PixelValue,PixelValue > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetMinMax",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetMinMax" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_GetMinMax" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetMinMax" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_Subresource,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ReplayController_GetMinMax" "', argument " "3"" of type '" "Subresource const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetMinMax" "', argument " "3"" of type '" "Subresource const &""'"); 
  }
  arg3 = reinterpret_cast< Subresource * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ReplayController_GetMinMax" "', argument " "4"" of type '" "CompType""'");
  } 
  arg4 = static_cast< CompType >(val4);
  result = (arg1)->GetMinMax(arg2,(Subresource const &)*arg3,arg4);
  {
    resultobj = ConvertToPy((rdcpair< PixelValue,PixelValue >&)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetHistogram(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  Subresource *arg3 = 0 ;
  CompType arg4 ;
  float arg5 ;
  float arg6 ;
  rdcfixedarray< bool,4 > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned char tempmem7[16*8] ;
  PyObject *swig_obj[7] ;
  rdcarray< uint32_t > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetHistogram",6,6,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetHistogram" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_GetHistogram" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetHistogram" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_Subresource,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ReplayController_GetHistogram" "', argument " "3"" of type '" "Subresource const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetHistogram" "', argument " "3"" of type '" "Subresource const &""'"); 
  }
  arg3 = reinterpret_cast< Subresource * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ReplayController_GetHistogram" "', argument " "4"" of type '" "CompType""'");
  } 
  arg4 = static_cast< CompType >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ReplayController_GetHistogram" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ReplayController_GetHistogram" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  {
    using array_type = std::remove_pointer<decltype(arg7)>::type;
    
    {
      tempalloc(arg7, tempmem7);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[5], indirect(arg7), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_GetHistogram' argument 7 of type 'rdcfixedarray< bool,4 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ReplayController_GetHistogram' argument 7 of type 'rdcfixedarray< bool,4 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg7); 
  }
  result = (arg1)->GetHistogram(arg2,(Subresource const &)*arg3,arg4,arg5,arg6,(rdcfixedarray< bool,4 > const &)*arg7);
  resultobj = SWIG_NewPointerObj((new rdcarray< uint32_t >(static_cast< const rdcarray< uint32_t >& >(result))), SWIGTYPE_p_rdcarrayT_unsigned_int_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_PixelHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  Subresource *arg5 = 0 ;
  CompType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  rdcarray< PixelModification > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_PixelHistory",5,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_PixelHistory" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_PixelHistory" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_PixelHistory" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReplayController_PixelHistory" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ReplayController_PixelHistory" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[3], &argp5, SWIGTYPE_p_Subresource,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ReplayController_PixelHistory" "', argument " "5"" of type '" "Subresource const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_PixelHistory" "', argument " "5"" of type '" "Subresource const &""'"); 
  }
  arg5 = reinterpret_cast< Subresource * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ReplayController_PixelHistory" "', argument " "6"" of type '" "CompType""'");
  } 
  arg6 = static_cast< CompType >(val6);
  result = (arg1)->PixelHistory(arg2,arg3,arg4,(Subresource const &)*arg5,arg6);
  resultobj = SWIG_NewPointerObj((new rdcarray< PixelModification >(static_cast< const rdcarray< PixelModification >& >(result))), SWIGTYPE_p_rdcarrayT_PixelModification_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_DebugVertex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  uint32_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  ShaderDebugTrace *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_DebugVertex",4,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_DebugVertex" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReplayController_DebugVertex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReplayController_DebugVertex" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ReplayController_DebugVertex" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ReplayController_DebugVertex" "', argument " "5"" of type '" "uint32_t""'");
  } 
  arg5 = static_cast< uint32_t >(val5);
  result = (ShaderDebugTrace *)(arg1)->DebugVertex(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_DebugPixel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  DebugPixelInputs *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  ShaderDebugTrace *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_DebugPixel",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_DebugPixel" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReplayController_DebugPixel" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReplayController_DebugPixel" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4, SWIGTYPE_p_DebugPixelInputs,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ReplayController_DebugPixel" "', argument " "4"" of type '" "DebugPixelInputs const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_DebugPixel" "', argument " "4"" of type '" "DebugPixelInputs const &""'"); 
  }
  arg4 = reinterpret_cast< DebugPixelInputs * >(argp4);
  result = (ShaderDebugTrace *)(arg1)->DebugPixel(arg2,arg3,(DebugPixelInputs const &)*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_DebugThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  rdcfixedarray< uint32_t,3 > *arg2 = 0 ;
  rdcfixedarray< uint32_t,3 > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  unsigned char tempmem3[16*8] ;
  PyObject *swig_obj[3] ;
  ShaderDebugTrace *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_DebugThread",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_DebugThread" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_DebugThread' argument 2 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ReplayController_DebugThread' argument 2 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg3)>::type;
    
    {
      tempalloc(arg3, tempmem3);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[1], indirect(arg3), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_DebugThread' argument 3 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ReplayController_DebugThread' argument 3 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg3); 
  }
  result = (ShaderDebugTrace *)(arg1)->DebugThread((rdcfixedarray< uint32_t,3 > const &)*arg2,(rdcfixedarray< uint32_t,3 > const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_DebugMeshThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  rdcfixedarray< uint32_t,3 > *arg2 = 0 ;
  rdcfixedarray< uint32_t,3 > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  unsigned char tempmem3[16*8] ;
  PyObject *swig_obj[3] ;
  ShaderDebugTrace *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_DebugMeshThread",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_DebugMeshThread" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_DebugMeshThread' argument 2 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ReplayController_DebugMeshThread' argument 2 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg3)>::type;
    
    {
      tempalloc(arg3, tempmem3);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[1], indirect(arg3), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_DebugMeshThread' argument 3 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ReplayController_DebugMeshThread' argument 3 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg3); 
  }
  result = (ShaderDebugTrace *)(arg1)->DebugMeshThread((rdcfixedarray< uint32_t,3 > const &)*arg2,(rdcfixedarray< uint32_t,3 > const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_ContinueDebug(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ShaderDebugger *arg2 = (ShaderDebugger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  rdcarray< ShaderDebugState > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_ContinueDebug" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderDebugger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_ContinueDebug" "', argument " "2"" of type '" "ShaderDebugger *""'"); 
  }
  arg2 = reinterpret_cast< ShaderDebugger * >(argp2);
  result = (arg1)->ContinueDebug(arg2);
  resultobj = SWIG_NewPointerObj((new rdcarray< ShaderDebugState >(static_cast< const rdcarray< ShaderDebugState >& >(result))), SWIGTYPE_p_rdcarrayT_ShaderDebugState_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_FreeTrace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ShaderDebugTrace *arg2 = (ShaderDebugTrace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_FreeTrace" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_FreeTrace" "', argument " "2"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg2 = reinterpret_cast< ShaderDebugTrace * >(argp2);
  (arg1)->FreeTrace(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetUsage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  rdcarray< EventUsage > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetUsage" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_GetUsage" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetUsage" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (arg1)->GetUsage(arg2);
  resultobj = SWIG_NewPointerObj((new rdcarray< EventUsage >(static_cast< const rdcarray< EventUsage >& >(result))), SWIGTYPE_p_rdcarrayT_EventUsage_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetCBufferVariableContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  ResourceId arg3 ;
  ShaderStage arg4 ;
  rdcstr *arg5 = 0 ;
  uint32_t arg6 ;
  ResourceId arg7 ;
  uint64_t arg8 ;
  uint64_t arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  rdcstr temp5 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  unsigned long val8 ;
  int ecode8 = 0 ;
  unsigned long val9 ;
  int ecode9 = 0 ;
  PyObject *swig_obj[9] ;
  rdcarray< ShaderVariable > result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetCBufferVariableContents",8,8,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetCBufferVariableContents" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_GetCBufferVariableContents" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetCBufferVariableContents" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ReplayController_GetCBufferVariableContents" "', argument " "3"" of type '" "ResourceId""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetCBufferVariableContents" "', argument " "3"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ReplayController_GetCBufferVariableContents" "', argument " "4"" of type '" "ShaderStage""'");
  } 
  arg4 = static_cast< ShaderStage >(val4);
  {
    tempset(arg5, &temp5);
    
    int res = ConvertFromPy(swig_obj[3], indirect(arg5));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_GetCBufferVariableContents' argument 5 of type 'rdcstr'"); 
    }
  }
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ReplayController_GetCBufferVariableContents" "', argument " "6"" of type '" "uint32_t""'");
  } 
  arg6 = static_cast< uint32_t >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[5], &argp7, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ReplayController_GetCBufferVariableContents" "', argument " "7"" of type '" "ResourceId""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetCBufferVariableContents" "', argument " "7"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_unsigned_SS_long(swig_obj[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ReplayController_GetCBufferVariableContents" "', argument " "8"" of type '" "uint64_t""'");
  } 
  arg8 = static_cast< uint64_t >(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_long(swig_obj[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ReplayController_GetCBufferVariableContents" "', argument " "9"" of type '" "uint64_t""'");
  } 
  arg9 = static_cast< uint64_t >(val9);
  result = (arg1)->GetCBufferVariableContents(arg2,arg3,arg4,(rdcstr const &)*arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj((new rdcarray< ShaderVariable >(static_cast< const rdcarray< ShaderVariable >& >(result))), SWIGTYPE_p_rdcarrayT_ShaderVariable_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_SaveTexture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  TextureSave *arg2 = 0 ;
  rdcstr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  rdcstr temp3 ;
  PyObject *swig_obj[3] ;
  ResultDetails result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_SaveTexture",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_SaveTexture" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_TextureSave,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_SaveTexture" "', argument " "2"" of type '" "TextureSave const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_SaveTexture" "', argument " "2"" of type '" "TextureSave const &""'"); 
  }
  arg2 = reinterpret_cast< TextureSave * >(argp2);
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayController_SaveTexture' argument 3 of type 'rdcstr'"); 
    }
  }
  result = (arg1)->SaveTexture((TextureSave const &)*arg2,(rdcstr const &)*arg3);
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetPostVSData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  MeshDataStage arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  MeshFormat result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetPostVSData",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetPostVSData" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReplayController_GetPostVSData" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReplayController_GetPostVSData" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ReplayController_GetPostVSData" "', argument " "4"" of type '" "MeshDataStage""'");
  } 
  arg4 = static_cast< MeshDataStage >(val4);
  result = (arg1)->GetPostVSData(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj((new MeshFormat(static_cast< const MeshFormat& >(result))), SWIGTYPE_p_MeshFormat, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetBufferData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  uint64_t arg3 ;
  uint64_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  unsigned long val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  bytebuf result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetBufferData",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetBufferData" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_GetBufferData" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetBufferData" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReplayController_GetBufferData" "', argument " "3"" of type '" "uint64_t""'");
  } 
  arg3 = static_cast< uint64_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_long(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ReplayController_GetBufferData" "', argument " "4"" of type '" "uint64_t""'");
  } 
  arg4 = static_cast< uint64_t >(val4);
  result = (arg1)->GetBufferData(arg2,arg3,arg4);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayController_GetTextureData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IReplayController *arg1 = (IReplayController *) 0 ;
  ResourceId arg2 ;
  Subresource *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bytebuf result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayController_GetTextureData",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayController_GetTextureData" "', argument " "1"" of type '" "IReplayController *""'"); 
  }
  arg1 = reinterpret_cast< IReplayController * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReplayController_GetTextureData" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetTextureData" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_Subresource,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ReplayController_GetTextureData" "', argument " "3"" of type '" "Subresource const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReplayController_GetTextureData" "', argument " "3"" of type '" "Subresource const &""'"); 
  }
  arg3 = reinterpret_cast< Subresource * >(argp3);
  result = (arg1)->GetTextureData(arg2,(Subresource const &)*arg3);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControl_Shutdown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ITargetControl *arg1 = (ITargetControl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControl_Shutdown",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ITargetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControl_Shutdown" "', argument " "1"" of type '" "ITargetControl *""'"); 
  }
  arg1 = reinterpret_cast< ITargetControl * >(argp1);
  (arg1)->Shutdown();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControl_Connected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ITargetControl *arg1 = (ITargetControl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControl_Connected",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ITargetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControl_Connected" "', argument " "1"" of type '" "ITargetControl *""'"); 
  }
  arg1 = reinterpret_cast< ITargetControl * >(argp1);
  result = (bool)(arg1)->Connected();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControl_GetTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ITargetControl *arg1 = (ITargetControl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControl_GetTarget",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ITargetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControl_GetTarget" "', argument " "1"" of type '" "ITargetControl *""'"); 
  }
  arg1 = reinterpret_cast< ITargetControl * >(argp1);
  result = (arg1)->GetTarget();
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControl_GetAPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ITargetControl *arg1 = (ITargetControl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControl_GetAPI",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ITargetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControl_GetAPI" "', argument " "1"" of type '" "ITargetControl *""'"); 
  }
  arg1 = reinterpret_cast< ITargetControl * >(argp1);
  result = (arg1)->GetAPI();
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControl_GetPID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ITargetControl *arg1 = (ITargetControl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControl_GetPID",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ITargetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControl_GetPID" "', argument " "1"" of type '" "ITargetControl *""'"); 
  }
  arg1 = reinterpret_cast< ITargetControl * >(argp1);
  result = (uint32_t)(arg1)->GetPID();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControl_GetBusyClient(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ITargetControl *arg1 = (ITargetControl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControl_GetBusyClient",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ITargetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControl_GetBusyClient" "', argument " "1"" of type '" "ITargetControl *""'"); 
  }
  arg1 = reinterpret_cast< ITargetControl * >(argp1);
  result = (arg1)->GetBusyClient();
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControl_TriggerCapture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ITargetControl *arg1 = (ITargetControl *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ITargetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControl_TriggerCapture" "', argument " "1"" of type '" "ITargetControl *""'"); 
  }
  arg1 = reinterpret_cast< ITargetControl * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TargetControl_TriggerCapture" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  (arg1)->TriggerCapture(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControl_QueueCapture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ITargetControl *arg1 = (ITargetControl *) 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControl_QueueCapture",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ITargetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControl_QueueCapture" "', argument " "1"" of type '" "ITargetControl *""'"); 
  }
  arg1 = reinterpret_cast< ITargetControl * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TargetControl_QueueCapture" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TargetControl_QueueCapture" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  (arg1)->QueueCapture(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControl_CopyCapture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ITargetControl *arg1 = (ITargetControl *) 0 ;
  uint32_t arg2 ;
  rdcstr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  rdcstr temp3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControl_CopyCapture",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ITargetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControl_CopyCapture" "', argument " "1"" of type '" "ITargetControl *""'"); 
  }
  arg1 = reinterpret_cast< ITargetControl * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TargetControl_CopyCapture" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'TargetControl_CopyCapture' argument 3 of type 'rdcstr'"); 
    }
  }
  (arg1)->CopyCapture(arg2,(rdcstr const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControl_DeleteCapture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ITargetControl *arg1 = (ITargetControl *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ITargetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControl_DeleteCapture" "', argument " "1"" of type '" "ITargetControl *""'"); 
  }
  arg1 = reinterpret_cast< ITargetControl * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TargetControl_DeleteCapture" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  (arg1)->DeleteCapture(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControl_ReceiveMessage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ITargetControl *arg1 = (ITargetControl *) 0 ;
  RENDERDOC_ProgressCallback arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  TargetControlMessage result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ITargetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControl_ReceiveMessage" "', argument " "1"" of type '" "ITargetControl *""'"); 
  }
  arg1 = reinterpret_cast< ITargetControl * >(argp1);
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<RENDERDOC_ProgressCallback>("TargetControl_ReceiveMessage", func, exHandle2);
  }
  result = (arg1)->ReceiveMessage(arg2);
  resultobj = SWIG_NewPointerObj((new TargetControlMessage(static_cast< const TargetControlMessage& >(result))), SWIGTYPE_p_TargetControlMessage, SWIG_POINTER_OWN |  0 );
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControl_CycleActiveWindow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ITargetControl *arg1 = (ITargetControl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControl_CycleActiveWindow",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ITargetControl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControl_CycleActiveWindow" "', argument " "1"" of type '" "ITargetControl *""'"); 
  }
  arg1 = reinterpret_cast< ITargetControl * >(argp1);
  (arg1)->CycleActiveWindow();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_GetAvailableGPUs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< GPUDevice > result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureAccess_GetAvailableGPUs",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_GetAvailableGPUs" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  result = (arg1)->GetAvailableGPUs();
  resultobj = SWIG_NewPointerObj((new rdcarray< GPUDevice >(static_cast< const rdcarray< GPUDevice >& >(result))), SWIGTYPE_p_rdcarrayT_GPUDevice_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_GetSectionCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureAccess_GetSectionCount",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_GetSectionCount" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  result = (int32_t)(arg1)->GetSectionCount();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_FindSectionByName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_FindSectionByName" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureAccess_FindSectionByName' argument 2 of type 'rdcstr'"); 
    }
  }
  result = (int32_t)(arg1)->FindSectionByName((rdcstr const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_FindSectionByType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  SectionType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_FindSectionByType" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureAccess_FindSectionByType" "', argument " "2"" of type '" "SectionType""'");
  } 
  arg2 = static_cast< SectionType >(val2);
  result = (int32_t)(arg1)->FindSectionByType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_GetSectionProperties(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SectionProperties result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_GetSectionProperties" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureAccess_GetSectionProperties" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  result = (arg1)->GetSectionProperties(arg2);
  resultobj = SWIG_NewPointerObj((new SectionProperties(static_cast< const SectionProperties& >(result))), SWIGTYPE_p_SectionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_GetSectionContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bytebuf result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_GetSectionContents" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureAccess_GetSectionContents" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  result = (arg1)->GetSectionContents(arg2);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_WriteSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  SectionProperties *arg2 = 0 ;
  bytebuf *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bytebuf temp3 ;
  PyObject *swig_obj[3] ;
  ResultDetails result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureAccess_WriteSection",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_WriteSection" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_SectionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CaptureAccess_WriteSection" "', argument " "2"" of type '" "SectionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CaptureAccess_WriteSection" "', argument " "2"" of type '" "SectionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< SectionProperties * >(argp2);
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureAccess_WriteSection' argument 3 of type 'bytebuf'"); 
    }
  }
  result = (arg1)->WriteSection((SectionProperties const &)*arg2,(bytebuf const &)*arg3);
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_HasCallstacks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureAccess_HasCallstacks",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_HasCallstacks" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  result = (bool)(arg1)->HasCallstacks();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_InitResolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  bool arg2 ;
  RENDERDOC_ProgressCallback arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  StackExceptionHandler exHandle3 ;
  PyObject *swig_obj[3] ;
  ResultDetails result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureAccess_InitResolver",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_InitResolver" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureAccess_InitResolver" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    PyObject *func = swig_obj[1];
    arg3 = ConvertFunc<RENDERDOC_ProgressCallback>("CaptureAccess_InitResolver", func, exHandle3);
  }
  result = (arg1)->InitResolver(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  {
    if(exHandle3.data().failFlag) {
      PyErr_Restore(exHandle3.data().exObj, exHandle3.data().valueObj, exHandle3.data().tracebackObj);
      SWIG_fail;
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_GetResolve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  rdcarray< uint64_t > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  rdcarray< rdcstr > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_GetResolve" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureAccess_GetResolve' argument 2 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'CaptureAccess_GetResolve' argument 2 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (arg1)->GetResolve((rdcarray< uint64_t > const &)*arg2);
  resultobj = SWIG_NewPointerObj((new rdcarray< rdcstr >(static_cast< const rdcarray< rdcstr >& >(result))), SWIGTYPE_p_rdcarrayT_rdcstr_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_DriverName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureAccess_DriverName",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_DriverName" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  result = (arg1)->DriverName();
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_EmbedDependenciesIntoCapture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResultDetails result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureAccess_EmbedDependenciesIntoCapture",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_EmbedDependenciesIntoCapture" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  result = (arg1)->EmbedDependenciesIntoCapture();
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_RemoveDependenciesFromCapture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResultDetails result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureAccess_RemoveDependenciesFromCapture",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_RemoveDependenciesFromCapture" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  result = (arg1)->RemoveDependenciesFromCapture();
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_HasEmbeddedDependencies(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureAccess_HasEmbeddedDependencies",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_HasEmbeddedDependencies" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  result = (bool)(arg1)->HasEmbeddedDependencies();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_HasPendingDependencies(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureAccess_HasPendingDependencies",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_HasPendingDependencies" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  result = (bool)(arg1)->HasPendingDependencies();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureAccess_GetPendingDependenciesNicknames(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureAccess *arg1 = (ICaptureAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< rdcstr > result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureAccess_GetPendingDependenciesNicknames",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureAccess_GetPendingDependenciesNicknames" "', argument " "1"" of type '" "ICaptureAccess *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureAccess * >(argp1);
  result = (arg1)->GetPendingDependenciesNicknames();
  resultobj = SWIG_NewPointerObj((new rdcarray< rdcstr >(static_cast< const rdcarray< rdcstr >& >(result))), SWIGTYPE_p_rdcarrayT_rdcstr_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteServer_ShutdownConnection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IRemoteServer *arg1 = (IRemoteServer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"RemoteServer_ShutdownConnection",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IRemoteServer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteServer_ShutdownConnection" "', argument " "1"" of type '" "IRemoteServer *""'"); 
  }
  arg1 = reinterpret_cast< IRemoteServer * >(argp1);
  (arg1)->ShutdownConnection();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteServer_ShutdownServerAndConnection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IRemoteServer *arg1 = (IRemoteServer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"RemoteServer_ShutdownServerAndConnection",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IRemoteServer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteServer_ShutdownServerAndConnection" "', argument " "1"" of type '" "IRemoteServer *""'"); 
  }
  arg1 = reinterpret_cast< IRemoteServer * >(argp1);
  (arg1)->ShutdownServerAndConnection();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteServer_Ping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IRemoteServer *arg1 = (IRemoteServer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResultDetails result;
  
  if (!SWIG_Python_UnpackTuple(args,"RemoteServer_Ping",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IRemoteServer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteServer_Ping" "', argument " "1"" of type '" "IRemoteServer *""'"); 
  }
  arg1 = reinterpret_cast< IRemoteServer * >(argp1);
  result = (arg1)->Ping();
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteServer_LocalProxies(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IRemoteServer *arg1 = (IRemoteServer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< rdcstr > result;
  
  if (!SWIG_Python_UnpackTuple(args,"RemoteServer_LocalProxies",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IRemoteServer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteServer_LocalProxies" "', argument " "1"" of type '" "IRemoteServer *""'"); 
  }
  arg1 = reinterpret_cast< IRemoteServer * >(argp1);
  result = (arg1)->LocalProxies();
  resultobj = SWIG_NewPointerObj((new rdcarray< rdcstr >(static_cast< const rdcarray< rdcstr >& >(result))), SWIGTYPE_p_rdcarrayT_rdcstr_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteServer_RemoteSupportedReplays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IRemoteServer *arg1 = (IRemoteServer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< rdcstr > result;
  
  if (!SWIG_Python_UnpackTuple(args,"RemoteServer_RemoteSupportedReplays",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IRemoteServer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteServer_RemoteSupportedReplays" "', argument " "1"" of type '" "IRemoteServer *""'"); 
  }
  arg1 = reinterpret_cast< IRemoteServer * >(argp1);
  result = (arg1)->RemoteSupportedReplays();
  resultobj = SWIG_NewPointerObj((new rdcarray< rdcstr >(static_cast< const rdcarray< rdcstr >& >(result))), SWIGTYPE_p_rdcarrayT_rdcstr_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteServer_GetHomeFolder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IRemoteServer *arg1 = (IRemoteServer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"RemoteServer_GetHomeFolder",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IRemoteServer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteServer_GetHomeFolder" "', argument " "1"" of type '" "IRemoteServer *""'"); 
  }
  arg1 = reinterpret_cast< IRemoteServer * >(argp1);
  result = (arg1)->GetHomeFolder();
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteServer_ListFolder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IRemoteServer *arg1 = (IRemoteServer *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  rdcarray< PathEntry > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IRemoteServer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteServer_ListFolder" "', argument " "1"" of type '" "IRemoteServer *""'"); 
  }
  arg1 = reinterpret_cast< IRemoteServer * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'RemoteServer_ListFolder' argument 2 of type 'rdcstr'"); 
    }
  }
  result = (arg1)->ListFolder((rdcstr const &)*arg2);
  resultobj = SWIG_NewPointerObj((new rdcarray< PathEntry >(static_cast< const rdcarray< PathEntry >& >(result))), SWIGTYPE_p_rdcarrayT_PathEntry_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteServer_ExecuteAndInject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IRemoteServer *arg1 = (IRemoteServer *) 0 ;
  rdcstr *arg2 = 0 ;
  rdcstr *arg3 = 0 ;
  rdcstr *arg4 = 0 ;
  rdcarray< EnvironmentModification > *arg5 = 0 ;
  CaptureOptions *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  rdcstr temp3 ;
  rdcstr temp4 ;
  unsigned char tempmem5[32] ;
  bool wasSelf5 = false ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  ExecuteResult result;
  
  if (!SWIG_Python_UnpackTuple(args,"RemoteServer_ExecuteAndInject",5,5,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IRemoteServer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteServer_ExecuteAndInject" "', argument " "1"" of type '" "IRemoteServer *""'"); 
  }
  arg1 = reinterpret_cast< IRemoteServer * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'RemoteServer_ExecuteAndInject' argument 2 of type 'rdcstr'"); 
    }
  }
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'RemoteServer_ExecuteAndInject' argument 3 of type 'rdcstr'"); 
    }
  }
  {
    tempset(arg4, &temp4);
    
    int res = ConvertFromPy(swig_obj[2], indirect(arg4));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'RemoteServer_ExecuteAndInject' argument 4 of type 'rdcstr'"); 
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg5)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem5) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg5, tempmem5);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[3], indirect(arg5), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'RemoteServer_ExecuteAndInject' argument 5 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'RemoteServer_ExecuteAndInject' argument 5 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[4], &argp6, SWIGTYPE_p_CaptureOptions,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "RemoteServer_ExecuteAndInject" "', argument " "6"" of type '" "CaptureOptions const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RemoteServer_ExecuteAndInject" "', argument " "6"" of type '" "CaptureOptions const &""'"); 
  }
  arg6 = reinterpret_cast< CaptureOptions * >(argp6);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg5); 
  }
  result = (arg1)->ExecuteAndInject((rdcstr const &)*arg2,(rdcstr const &)*arg3,(rdcstr const &)*arg4,(rdcarray< EnvironmentModification > const &)*arg5,(CaptureOptions const &)*arg6);
  resultobj = SWIG_NewPointerObj((new ExecuteResult(static_cast< const ExecuteResult& >(result))), SWIGTYPE_p_ExecuteResult, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteServer_TakeOwnershipCapture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IRemoteServer *arg1 = (IRemoteServer *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IRemoteServer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteServer_TakeOwnershipCapture" "', argument " "1"" of type '" "IRemoteServer *""'"); 
  }
  arg1 = reinterpret_cast< IRemoteServer * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'RemoteServer_TakeOwnershipCapture' argument 2 of type 'rdcstr'"); 
    }
  }
  (arg1)->TakeOwnershipCapture((rdcstr const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteServer_CopyCaptureToRemote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IRemoteServer *arg1 = (IRemoteServer *) 0 ;
  rdcstr *arg2 = 0 ;
  RENDERDOC_ProgressCallback arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  StackExceptionHandler exHandle3 ;
  PyObject *swig_obj[3] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"RemoteServer_CopyCaptureToRemote",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IRemoteServer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteServer_CopyCaptureToRemote" "', argument " "1"" of type '" "IRemoteServer *""'"); 
  }
  arg1 = reinterpret_cast< IRemoteServer * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'RemoteServer_CopyCaptureToRemote' argument 2 of type 'rdcstr'"); 
    }
  }
  {
    PyObject *func = swig_obj[1];
    arg3 = ConvertFunc<RENDERDOC_ProgressCallback>("RemoteServer_CopyCaptureToRemote", func, exHandle3);
  }
  result = (arg1)->CopyCaptureToRemote((rdcstr const &)*arg2,arg3);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  {
    if(exHandle3.data().failFlag) {
      PyErr_Restore(exHandle3.data().exObj, exHandle3.data().valueObj, exHandle3.data().tracebackObj);
      SWIG_fail;
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteServer_CopyCaptureFromRemote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IRemoteServer *arg1 = (IRemoteServer *) 0 ;
  rdcstr *arg2 = 0 ;
  rdcstr *arg3 = 0 ;
  RENDERDOC_ProgressCallback arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  rdcstr temp3 ;
  StackExceptionHandler exHandle4 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args,"RemoteServer_CopyCaptureFromRemote",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IRemoteServer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteServer_CopyCaptureFromRemote" "', argument " "1"" of type '" "IRemoteServer *""'"); 
  }
  arg1 = reinterpret_cast< IRemoteServer * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'RemoteServer_CopyCaptureFromRemote' argument 2 of type 'rdcstr'"); 
    }
  }
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'RemoteServer_CopyCaptureFromRemote' argument 3 of type 'rdcstr'"); 
    }
  }
  {
    PyObject *func = swig_obj[2];
    arg4 = ConvertFunc<RENDERDOC_ProgressCallback>("RemoteServer_CopyCaptureFromRemote", func, exHandle4);
  }
  (arg1)->CopyCaptureFromRemote((rdcstr const &)*arg2,(rdcstr const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle4.data().failFlag) {
      PyErr_Restore(exHandle4.data().exObj, exHandle4.data().valueObj, exHandle4.data().tracebackObj);
      SWIG_fail;
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteServer_OpenCapture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IRemoteServer *arg1 = (IRemoteServer *) 0 ;
  uint32_t arg2 ;
  rdcstr *arg3 = 0 ;
  ReplayOptions *arg4 = 0 ;
  RENDERDOC_ProgressCallback arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  rdcstr temp3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  StackExceptionHandler exHandle5 ;
  PyObject *swig_obj[5] ;
  SwigValueWrapper< rdcpair< ResultDetails,IReplayController * > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"RemoteServer_OpenCapture",4,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IRemoteServer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteServer_OpenCapture" "', argument " "1"" of type '" "IRemoteServer *""'"); 
  }
  arg1 = reinterpret_cast< IRemoteServer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RemoteServer_OpenCapture" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'RemoteServer_OpenCapture' argument 3 of type 'rdcstr'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4, SWIGTYPE_p_ReplayOptions,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RemoteServer_OpenCapture" "', argument " "4"" of type '" "ReplayOptions const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RemoteServer_OpenCapture" "', argument " "4"" of type '" "ReplayOptions const &""'"); 
  }
  arg4 = reinterpret_cast< ReplayOptions * >(argp4);
  {
    PyObject *func = swig_obj[3];
    arg5 = ConvertFunc<RENDERDOC_ProgressCallback>("RemoteServer_OpenCapture", func, exHandle5);
  }
  result = (arg1)->OpenCapture(arg2,(rdcstr const &)*arg3,(ReplayOptions const &)*arg4,arg5);
  {
    resultobj = ConvertToPy((rdcpair< ResultDetails,IReplayController * >&)result);
  }
  {
    if(exHandle5.data().failFlag) {
      PyErr_Restore(exHandle5.data().exObj, exHandle5.data().valueObj, exHandle5.data().tracebackObj);
      SWIG_fail;
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteServer_CloseCapture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IRemoteServer *arg1 = (IRemoteServer *) 0 ;
  IReplayController *arg2 = (IReplayController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IRemoteServer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteServer_CloseCapture" "', argument " "1"" of type '" "IRemoteServer *""'"); 
  }
  arg1 = reinterpret_cast< IRemoteServer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_IReplayController, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RemoteServer_CloseCapture" "', argument " "2"" of type '" "IReplayController *""'"); 
  }
  arg2 = reinterpret_cast< IReplayController * >(argp2);
  (arg1)->CloseCapture(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_Shutdown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFile_Shutdown",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_Shutdown" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  (arg1)->Shutdown();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_OpenFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  rdcstr *arg2 = 0 ;
  rdcstr *arg3 = 0 ;
  RENDERDOC_ProgressCallback arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  rdcstr temp3 ;
  StackExceptionHandler exHandle4 ;
  PyObject *swig_obj[4] ;
  ResultDetails result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFile_OpenFile",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_OpenFile" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureFile_OpenFile' argument 2 of type 'rdcstr'"); 
    }
  }
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureFile_OpenFile' argument 3 of type 'rdcstr'"); 
    }
  }
  {
    PyObject *func = swig_obj[2];
    arg4 = ConvertFunc<RENDERDOC_ProgressCallback>("CaptureFile_OpenFile", func, exHandle4);
  }
  result = (arg1)->OpenFile((rdcstr const &)*arg2,(rdcstr const &)*arg3,arg4);
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  {
    if(exHandle4.data().failFlag) {
      PyErr_Restore(exHandle4.data().exObj, exHandle4.data().valueObj, exHandle4.data().tracebackObj);
      SWIG_fail;
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_OpenBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  bytebuf *arg2 = 0 ;
  rdcstr *arg3 = 0 ;
  RENDERDOC_ProgressCallback arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bytebuf temp2 ;
  rdcstr temp3 ;
  StackExceptionHandler exHandle4 ;
  PyObject *swig_obj[4] ;
  ResultDetails result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFile_OpenBuffer",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_OpenBuffer" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureFile_OpenBuffer' argument 2 of type 'bytebuf'"); 
    }
  }
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureFile_OpenBuffer' argument 3 of type 'rdcstr'"); 
    }
  }
  {
    PyObject *func = swig_obj[2];
    arg4 = ConvertFunc<RENDERDOC_ProgressCallback>("CaptureFile_OpenBuffer", func, exHandle4);
  }
  result = (arg1)->OpenBuffer((bytebuf const &)*arg2,(rdcstr const &)*arg3,arg4);
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  {
    if(exHandle4.data().failFlag) {
      PyErr_Restore(exHandle4.data().exObj, exHandle4.data().valueObj, exHandle4.data().tracebackObj);
      SWIG_fail;
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_CopyFileTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  ResultDetails result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_CopyFileTo" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureFile_CopyFileTo' argument 2 of type 'rdcstr'"); 
    }
  }
  result = (arg1)->CopyFileTo((rdcstr const &)*arg2);
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_Convert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  rdcstr *arg2 = 0 ;
  rdcstr *arg3 = 0 ;
  SDFile *arg4 = (SDFile *) 0 ;
  RENDERDOC_ProgressCallback arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  rdcstr temp3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  StackExceptionHandler exHandle5 ;
  PyObject *swig_obj[5] ;
  ResultDetails result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFile_Convert",4,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_Convert" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureFile_Convert' argument 2 of type 'rdcstr'"); 
    }
  }
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureFile_Convert' argument 3 of type 'rdcstr'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_SDFile, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CaptureFile_Convert" "', argument " "4"" of type '" "SDFile const *""'"); 
  }
  arg4 = reinterpret_cast< SDFile * >(argp4);
  {
    PyObject *func = swig_obj[3];
    arg5 = ConvertFunc<RENDERDOC_ProgressCallback>("CaptureFile_Convert", func, exHandle5);
  }
  result = (arg1)->Convert((rdcstr const &)*arg2,(rdcstr const &)*arg3,(SDFile const *)arg4,arg5);
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  {
    if(exHandle5.data().failFlag) {
      PyErr_Restore(exHandle5.data().exObj, exHandle5.data().valueObj, exHandle5.data().tracebackObj);
      SWIG_fail;
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_GetCaptureFileFormats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< CaptureFileFormat > result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFile_GetCaptureFileFormats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_GetCaptureFileFormats" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  result = (arg1)->GetCaptureFileFormats();
  resultobj = SWIG_NewPointerObj((new rdcarray< CaptureFileFormat >(static_cast< const rdcarray< CaptureFileFormat >& >(result))), SWIGTYPE_p_rdcarrayT_CaptureFileFormat_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_LocalReplaySupport(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ReplaySupport result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFile_LocalReplaySupport",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_LocalReplaySupport" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  result = (ReplaySupport)(arg1)->LocalReplaySupport();
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ReplaySupport->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_RecordedMachineIdent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFile_RecordedMachineIdent",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_RecordedMachineIdent" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  result = (arg1)->RecordedMachineIdent();
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_TimestampBase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFile_TimestampBase",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_TimestampBase" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  result = (uint64_t)(arg1)->TimestampBase();
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_TimestampFrequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFile_TimestampFrequency",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_TimestampFrequency" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  result = (double)(arg1)->TimestampFrequency();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_SetMetadata(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  rdcstr *arg2 = 0 ;
  uint64_t arg3 ;
  FileType arg4 ;
  uint32_t arg5 ;
  uint32_t arg6 ;
  bytebuf *arg7 = 0 ;
  uint64_t arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  bytebuf temp7 ;
  unsigned long val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject *swig_obj[9] ;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFile_SetMetadata",8,8,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_SetMetadata" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureFile_SetMetadata' argument 2 of type 'rdcstr'"); 
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CaptureFile_SetMetadata" "', argument " "3"" of type '" "uint64_t""'");
  } 
  arg3 = static_cast< uint64_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CaptureFile_SetMetadata" "', argument " "4"" of type '" "FileType""'");
  } 
  arg4 = static_cast< FileType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CaptureFile_SetMetadata" "', argument " "5"" of type '" "uint32_t""'");
  } 
  arg5 = static_cast< uint32_t >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CaptureFile_SetMetadata" "', argument " "6"" of type '" "uint32_t""'");
  } 
  arg6 = static_cast< uint32_t >(val6);
  {
    tempset(arg7, &temp7);
    
    int res = ConvertFromPy(swig_obj[5], indirect(arg7));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureFile_SetMetadata' argument 7 of type 'bytebuf'"); 
    }
  }
  ecode8 = SWIG_AsVal_unsigned_SS_long(swig_obj[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CaptureFile_SetMetadata" "', argument " "8"" of type '" "uint64_t""'");
  } 
  arg8 = static_cast< uint64_t >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "CaptureFile_SetMetadata" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  (arg1)->SetMetadata((rdcstr const &)*arg2,arg3,arg4,arg5,arg6,(bytebuf const &)*arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_OpenCapture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  ReplayOptions *arg2 = 0 ;
  RENDERDOC_ProgressCallback arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  StackExceptionHandler exHandle3 ;
  PyObject *swig_obj[3] ;
  SwigValueWrapper< rdcpair< ResultDetails,IReplayController * > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFile_OpenCapture",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_OpenCapture" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ReplayOptions,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CaptureFile_OpenCapture" "', argument " "2"" of type '" "ReplayOptions const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CaptureFile_OpenCapture" "', argument " "2"" of type '" "ReplayOptions const &""'"); 
  }
  arg2 = reinterpret_cast< ReplayOptions * >(argp2);
  {
    PyObject *func = swig_obj[1];
    arg3 = ConvertFunc<RENDERDOC_ProgressCallback>("CaptureFile_OpenCapture", func, exHandle3);
  }
  result = (arg1)->OpenCapture((ReplayOptions const &)*arg2,arg3);
  {
    resultobj = ConvertToPy((rdcpair< ResultDetails,IReplayController * >&)result);
  }
  {
    if(exHandle3.data().failFlag) {
      PyErr_Restore(exHandle3.data().exObj, exHandle3.data().valueObj, exHandle3.data().tracebackObj);
      SWIG_fail;
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_GetStructuredData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDFile *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFile_GetStructuredData",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_GetStructuredData" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  result = (SDFile *) &(arg1)->GetStructuredData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDFile, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_SetStructuredData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  SDFile *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_SetStructuredData" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_SDFile,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CaptureFile_SetStructuredData" "', argument " "2"" of type '" "SDFile const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CaptureFile_SetStructuredData" "', argument " "2"" of type '" "SDFile const &""'"); 
  }
  arg2 = reinterpret_cast< SDFile * >(argp2);
  (arg1)->SetStructuredData((SDFile const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFile_GetThumbnail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *arg1 = (ICaptureFile *) 0 ;
  FileType arg2 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Thumbnail result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFile_GetThumbnail",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICaptureFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFile_GetThumbnail" "', argument " "1"" of type '" "ICaptureFile *""'"); 
  }
  arg1 = reinterpret_cast< ICaptureFile * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureFile_GetThumbnail" "', argument " "2"" of type '" "FileType""'");
  } 
  arg2 = static_cast< FileType >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CaptureFile_GetThumbnail" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  result = (arg1)->GetThumbnail(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new Thumbnail(static_cast< const Thumbnail& >(result))), SWIGTYPE_p_Thumbnail, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Camera_Shutdown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICamera *arg1 = (ICamera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Camera_Shutdown",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_Shutdown" "', argument " "1"" of type '" "ICamera *""'"); 
  }
  arg1 = reinterpret_cast< ICamera * >(argp1);
  (arg1)->Shutdown();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Camera_SetNearFar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICamera *arg1 = (ICamera *) 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Camera_SetNearFar",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_SetNearFar" "', argument " "1"" of type '" "ICamera *""'"); 
  }
  arg1 = reinterpret_cast< ICamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Camera_SetNearFar" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Camera_SetNearFar" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->SetNearFar(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Camera_SetPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICamera *arg1 = (ICamera *) 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Camera_SetPosition",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_SetPosition" "', argument " "1"" of type '" "ICamera *""'"); 
  }
  arg1 = reinterpret_cast< ICamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Camera_SetPosition" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Camera_SetPosition" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Camera_SetPosition" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->SetPosition(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Camera_SetFPSRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICamera *arg1 = (ICamera *) 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Camera_SetFPSRotation",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_SetFPSRotation" "', argument " "1"" of type '" "ICamera *""'"); 
  }
  arg1 = reinterpret_cast< ICamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Camera_SetFPSRotation" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Camera_SetFPSRotation" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Camera_SetFPSRotation" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->SetFPSRotation(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Camera_SetArcballDistance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICamera *arg1 = (ICamera *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_SetArcballDistance" "', argument " "1"" of type '" "ICamera *""'"); 
  }
  arg1 = reinterpret_cast< ICamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Camera_SetArcballDistance" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->SetArcballDistance(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Camera_ResetArcball(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICamera *arg1 = (ICamera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Camera_ResetArcball",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_ResetArcball" "', argument " "1"" of type '" "ICamera *""'"); 
  }
  arg1 = reinterpret_cast< ICamera * >(argp1);
  (arg1)->ResetArcball();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Camera_RotateArcball(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICamera *arg1 = (ICamera *) 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  if (!SWIG_Python_UnpackTuple(args,"Camera_RotateArcball",4,4,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_RotateArcball" "', argument " "1"" of type '" "ICamera *""'"); 
  }
  arg1 = reinterpret_cast< ICamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Camera_RotateArcball" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Camera_RotateArcball" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Camera_RotateArcball" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Camera_RotateArcball" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->RotateArcball(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Camera_GetPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICamera *arg1 = (ICamera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatVector result;
  
  if (!SWIG_Python_UnpackTuple(args,"Camera_GetPosition",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_GetPosition" "', argument " "1"" of type '" "ICamera *""'"); 
  }
  arg1 = reinterpret_cast< ICamera * >(argp1);
  result = (arg1)->GetPosition();
  resultobj = SWIG_NewPointerObj((new FloatVector(static_cast< const FloatVector& >(result))), SWIGTYPE_p_FloatVector, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Camera_GetForward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICamera *arg1 = (ICamera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatVector result;
  
  if (!SWIG_Python_UnpackTuple(args,"Camera_GetForward",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_GetForward" "', argument " "1"" of type '" "ICamera *""'"); 
  }
  arg1 = reinterpret_cast< ICamera * >(argp1);
  result = (arg1)->GetForward();
  resultobj = SWIG_NewPointerObj((new FloatVector(static_cast< const FloatVector& >(result))), SWIGTYPE_p_FloatVector, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Camera_GetRight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICamera *arg1 = (ICamera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatVector result;
  
  if (!SWIG_Python_UnpackTuple(args,"Camera_GetRight",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_GetRight" "', argument " "1"" of type '" "ICamera *""'"); 
  }
  arg1 = reinterpret_cast< ICamera * >(argp1);
  result = (arg1)->GetRight();
  resultobj = SWIG_NewPointerObj((new FloatVector(static_cast< const FloatVector& >(result))), SWIGTYPE_p_FloatVector, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Camera_GetUp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICamera *arg1 = (ICamera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatVector result;
  
  if (!SWIG_Python_UnpackTuple(args,"Camera_GetUp",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Camera_GetUp" "', argument " "1"" of type '" "ICamera *""'"); 
  }
  arg1 = reinterpret_cast< ICamera * >(argp1);
  result = (arg1)->GetUp();
  resultobj = SWIG_NewPointerObj((new FloatVector(static_cast< const FloatVector& >(result))), SWIGTYPE_p_FloatVector, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CameraType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  ICamera *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "InitCamera" "', argument " "1"" of type '" "CameraType""'");
  } 
  arg1 = static_cast< CameraType >(val1);
  result = (ICamera *)RENDERDOC_InitCamera(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ICamera, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HalfToFloat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint16_t arg1 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_short(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "HalfToFloat" "', argument " "1"" of type '" "uint16_t""'");
  } 
  arg1 = static_cast< uint16_t >(val1);
  result = (float)RENDERDOC_HalfToFloat(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatToHalf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  uint16_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FloatToHalf" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  result = (uint16_t)RENDERDOC_FloatToHalf(arg1);
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NumVerticesPerPrimitive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Topology arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NumVerticesPerPrimitive" "', argument " "1"" of type '" "Topology""'");
  } 
  arg1 = static_cast< Topology >(val1);
  result = (uint32_t)RENDERDOC_NumVerticesPerPrimitive(arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Topology arg1 ;
  uint32_t arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexOffset",2,2,swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "VertexOffset" "', argument " "1"" of type '" "Topology""'");
  } 
  arg1 = static_cast< Topology >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VertexOffset" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  result = (uint32_t)RENDERDOC_VertexOffset(arg1,arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OpenCaptureFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ICaptureFile *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"OpenCaptureFile",0,0,0)) SWIG_fail;
  result = (ICaptureFile *)RENDERDOC_OpenCaptureFile();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ICaptureFile, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreateTargetControl(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  uint32_t arg2 ;
  rdcstr *arg3 = 0 ;
  bool arg4 ;
  rdcstr temp1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  rdcstr temp3 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  ITargetControl *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CreateTargetControl",4,4,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CreateTargetControl' argument 1 of type 'rdcstr'"); 
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateTargetControl" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[2], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CreateTargetControl' argument 3 of type 'rdcstr'"); 
    }
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CreateTargetControl" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (ITargetControl *)RENDERDOC_CreateTargetControl((rdcstr const &)*arg1,arg2,(rdcstr const &)*arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ITargetControl, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EnumerateRemoteTargets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  uint32_t arg2 ;
  rdcstr temp1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"EnumerateRemoteTargets",2,2,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'EnumerateRemoteTargets' argument 1 of type 'rdcstr'"); 
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EnumerateRemoteTargets" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  result = (uint32_t)RENDERDOC_EnumerateRemoteTargets((rdcstr const &)*arg1,arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreateRemoteServerConnection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  IRemoteServer **arg2 = (IRemoteServer **) 0 ;
  rdcstr temp1 ;
  IRemoteServer *outRenderer2 ;
  PyObject *swig_obj[1] ;
  ResultDetails result;
  
  {
    outRenderer2 = NULL;
    arg2 = &outRenderer2;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CreateRemoteServerConnection' argument 1 of type 'rdcstr'"); 
    }
  }
  result = RENDERDOC_CreateRemoteServerConnection((rdcstr const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  {
    PyObject *retVal = resultobj;
    resultobj = PyTuple_New(2);
    if(resultobj)
    {
      PyTuple_SetItem(resultobj, 0, retVal);
      PyTuple_SetItem(resultobj, 1, SWIG_NewPointerObj(SWIG_as_voidptr(outRenderer2), SWIGTYPE_p_IRemoteServer, 0));
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CheckRemoteServerConnection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  rdcstr temp1 ;
  PyObject *swig_obj[1] ;
  ResultDetails result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CheckRemoteServerConnection' argument 1 of type 'rdcstr'"); 
    }
  }
  result = RENDERDOC_CheckRemoteServerConnection((rdcstr const &)*arg1);
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BecomeRemoteServer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  uint16_t arg2 ;
  RENDERDOC_KillCallback arg3 ;
  SwigValueWrapper< std::function< WindowingData (bool,rdcarray< WindowingSystem > const &) > > arg4 ;
  rdcstr temp1 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  StackExceptionHandler exHandle3 ;
  StackExceptionHandler exHandle4 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args,"BecomeRemoteServer",4,4,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'BecomeRemoteServer' argument 1 of type 'rdcstr'"); 
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BecomeRemoteServer" "', argument " "2"" of type '" "uint16_t""'");
  } 
  arg2 = static_cast< uint16_t >(val2);
  {
    PyObject *func = swig_obj[2];
    arg3 = ConvertFunc<RENDERDOC_KillCallback>("BecomeRemoteServer", func, exHandle3);
  }
  {
    PyObject *func = swig_obj[3];
    arg4 = ConvertFunc<RENDERDOC_PreviewWindowCallback>("BecomeRemoteServer", func, exHandle4);
  }
  RENDERDOC_BecomeRemoteServer((rdcstr const &)*arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle3.data().failFlag) {
      PyErr_Restore(exHandle3.data().exObj, exHandle3.data().valueObj, exHandle3.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    if(exHandle4.data().failFlag) {
      PyErr_Restore(exHandle4.data().exObj, exHandle4.data().valueObj, exHandle4.data().tracebackObj);
      SWIG_fail;
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GetDefaultCaptureOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  
  {
    arg1 = new CaptureOptions; 
  }
  if (!SWIG_Python_UnpackTuple(args,"GetDefaultCaptureOptions",0,0,0)) SWIG_fail;
  RENDERDOC_GetDefaultCaptureOptions(arg1);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj(arg1, SWIGTYPE_p_CaptureOptions, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StartGlobalHook(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  rdcstr *arg2 = 0 ;
  CaptureOptions *arg3 = 0 ;
  rdcstr temp1 ;
  rdcstr temp2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  ResultDetails result;
  
  if (!SWIG_Python_UnpackTuple(args,"StartGlobalHook",3,3,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'StartGlobalHook' argument 1 of type 'rdcstr'"); 
    }
  }
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'StartGlobalHook' argument 2 of type 'rdcstr'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_CaptureOptions,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StartGlobalHook" "', argument " "3"" of type '" "CaptureOptions const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StartGlobalHook" "', argument " "3"" of type '" "CaptureOptions const &""'"); 
  }
  arg3 = reinterpret_cast< CaptureOptions * >(argp3);
  result = RENDERDOC_StartGlobalHook((rdcstr const &)*arg1,(rdcstr const &)*arg2,(CaptureOptions const &)*arg3);
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StopGlobalHook(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args,"StopGlobalHook",0,0,0)) SWIG_fail;
  RENDERDOC_StopGlobalHook();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IsGlobalHookActive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"IsGlobalHookActive",0,0,0)) SWIG_fail;
  result = (bool)RENDERDOC_IsGlobalHookActive();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CanGlobalHook(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CanGlobalHook",0,0,0)) SWIG_fail;
  result = (bool)RENDERDOC_CanGlobalHook();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExecuteAndInject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  rdcstr *arg2 = 0 ;
  rdcstr *arg3 = 0 ;
  rdcarray< EnvironmentModification > *arg4 = 0 ;
  rdcstr *arg5 = 0 ;
  CaptureOptions *arg6 = 0 ;
  bool arg7 ;
  rdcstr temp1 ;
  rdcstr temp2 ;
  rdcstr temp3 ;
  unsigned char tempmem4[32] ;
  bool wasSelf4 = false ;
  rdcstr temp5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  ExecuteResult result;
  
  if (!SWIG_Python_UnpackTuple(args,"ExecuteAndInject",7,7,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ExecuteAndInject' argument 1 of type 'rdcstr'"); 
    }
  }
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ExecuteAndInject' argument 2 of type 'rdcstr'"); 
    }
  }
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[2], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ExecuteAndInject' argument 3 of type 'rdcstr'"); 
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg4)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem4) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg4, tempmem4);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[3], indirect(arg4), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ExecuteAndInject' argument 4 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ExecuteAndInject' argument 4 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    tempset(arg5, &temp5);
    
    int res = ConvertFromPy(swig_obj[4], indirect(arg5));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ExecuteAndInject' argument 5 of type 'rdcstr'"); 
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_CaptureOptions,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ExecuteAndInject" "', argument " "6"" of type '" "CaptureOptions const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExecuteAndInject" "', argument " "6"" of type '" "CaptureOptions const &""'"); 
  }
  arg6 = reinterpret_cast< CaptureOptions * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ExecuteAndInject" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg4); 
  }
  result = RENDERDOC_ExecuteAndInject((rdcstr const &)*arg1,(rdcstr const &)*arg2,(rdcstr const &)*arg3,(rdcarray< EnvironmentModification > const &)*arg4,(rdcstr const &)*arg5,(CaptureOptions const &)*arg6,arg7);
  resultobj = SWIG_NewPointerObj((new ExecuteResult(static_cast< const ExecuteResult& >(result))), SWIGTYPE_p_ExecuteResult, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InjectIntoProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  rdcarray< EnvironmentModification > *arg2 = 0 ;
  rdcstr *arg3 = 0 ;
  CaptureOptions *arg4 = 0 ;
  bool arg5 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  rdcstr temp3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  ExecuteResult result;
  
  if (!SWIG_Python_UnpackTuple(args,"InjectIntoProcess",5,5,swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "InjectIntoProcess" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[1], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'InjectIntoProcess' argument 2 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'InjectIntoProcess' argument 2 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[2], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'InjectIntoProcess' argument 3 of type 'rdcstr'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_CaptureOptions,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InjectIntoProcess" "', argument " "4"" of type '" "CaptureOptions const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InjectIntoProcess" "', argument " "4"" of type '" "CaptureOptions const &""'"); 
  }
  arg4 = reinterpret_cast< CaptureOptions * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "InjectIntoProcess" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = RENDERDOC_InjectIntoProcess(arg1,(rdcarray< EnvironmentModification > const &)*arg2,(rdcstr const &)*arg3,(CaptureOptions const &)*arg4,arg5);
  resultobj = SWIG_NewPointerObj((new ExecuteResult(static_cast< const ExecuteResult& >(result))), SWIGTYPE_p_ExecuteResult, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CanSelfHostedCapture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  rdcstr temp1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CanSelfHostedCapture' argument 1 of type 'rdcstr'"); 
    }
  }
  result = (bool)RENDERDOC_CanSelfHostedCapture((rdcstr const &)*arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StartSelfHostCapture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  rdcstr temp1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'StartSelfHostCapture' argument 1 of type 'rdcstr'"); 
    }
  }
  RENDERDOC_StartSelfHostCapture((rdcstr const &)*arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EndSelfHostCapture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  rdcstr temp1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'EndSelfHostCapture' argument 1 of type 'rdcstr'"); 
    }
  }
  RENDERDOC_EndSelfHostCapture((rdcstr const &)*arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VulkanLayerRegistrationInfo_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VulkanLayerRegistrationInfo *arg1 = (VulkanLayerRegistrationInfo *) 0 ;
  VulkanLayerFlags arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VulkanLayerRegistrationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VulkanLayerRegistrationInfo_flags_set" "', argument " "1"" of type '" "VulkanLayerRegistrationInfo *""'"); 
  }
  arg1 = reinterpret_cast< VulkanLayerRegistrationInfo * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VulkanLayerRegistrationInfo_flags_set" "', argument " "2"" of type '" "VulkanLayerFlags""'");
  } 
  arg2 = static_cast< VulkanLayerFlags >(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VulkanLayerRegistrationInfo_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VulkanLayerRegistrationInfo *arg1 = (VulkanLayerRegistrationInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VulkanLayerFlags result;
  
  if (!SWIG_Python_UnpackTuple(args,"VulkanLayerRegistrationInfo_flags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VulkanLayerRegistrationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VulkanLayerRegistrationInfo_flags_get" "', argument " "1"" of type '" "VulkanLayerRegistrationInfo *""'"); 
  }
  arg1 = reinterpret_cast< VulkanLayerRegistrationInfo * >(argp1);
  result = (VulkanLayerFlags) ((arg1)->flags);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_VulkanLayerFlags->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VulkanLayerRegistrationInfo_myJSONs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VulkanLayerRegistrationInfo *arg1 = (VulkanLayerRegistrationInfo *) 0 ;
  rdcarray< rdcstr > *arg2 = (rdcarray< rdcstr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VulkanLayerRegistrationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VulkanLayerRegistrationInfo_myJSONs_set" "', argument " "1"" of type '" "VulkanLayerRegistrationInfo *""'"); 
  }
  arg1 = reinterpret_cast< VulkanLayerRegistrationInfo * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VulkanLayerRegistrationInfo_myJSONs_set' argument 2 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VulkanLayerRegistrationInfo_myJSONs_set' argument 2 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->myJSONs = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VulkanLayerRegistrationInfo_myJSONs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VulkanLayerRegistrationInfo *arg1 = (VulkanLayerRegistrationInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< rdcstr > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VulkanLayerRegistrationInfo_myJSONs_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VulkanLayerRegistrationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VulkanLayerRegistrationInfo_myJSONs_get" "', argument " "1"" of type '" "VulkanLayerRegistrationInfo *""'"); 
  }
  arg1 = reinterpret_cast< VulkanLayerRegistrationInfo * >(argp1);
  result = (rdcarray< rdcstr > *)& ((arg1)->myJSONs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_rdcstr_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VulkanLayerRegistrationInfo_otherJSONs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VulkanLayerRegistrationInfo *arg1 = (VulkanLayerRegistrationInfo *) 0 ;
  rdcarray< rdcstr > *arg2 = (rdcarray< rdcstr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VulkanLayerRegistrationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VulkanLayerRegistrationInfo_otherJSONs_set" "', argument " "1"" of type '" "VulkanLayerRegistrationInfo *""'"); 
  }
  arg1 = reinterpret_cast< VulkanLayerRegistrationInfo * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VulkanLayerRegistrationInfo_otherJSONs_set' argument 2 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VulkanLayerRegistrationInfo_otherJSONs_set' argument 2 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->otherJSONs = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VulkanLayerRegistrationInfo_otherJSONs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VulkanLayerRegistrationInfo *arg1 = (VulkanLayerRegistrationInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< rdcstr > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VulkanLayerRegistrationInfo_otherJSONs_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VulkanLayerRegistrationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VulkanLayerRegistrationInfo_otherJSONs_get" "', argument " "1"" of type '" "VulkanLayerRegistrationInfo *""'"); 
  }
  arg1 = reinterpret_cast< VulkanLayerRegistrationInfo * >(argp1);
  result = (rdcarray< rdcstr > *)& ((arg1)->otherJSONs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_rdcstr_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_VulkanLayerRegistrationInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VulkanLayerRegistrationInfo *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_VulkanLayerRegistrationInfo",0,0,0)) SWIG_fail;
  result = (VulkanLayerRegistrationInfo *)new VulkanLayerRegistrationInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VulkanLayerRegistrationInfo, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_VulkanLayerRegistrationInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VulkanLayerRegistrationInfo *arg1 = (VulkanLayerRegistrationInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VulkanLayerRegistrationInfo",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VulkanLayerRegistrationInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VulkanLayerRegistrationInfo" "', argument " "1"" of type '" "VulkanLayerRegistrationInfo *""'"); 
  }
  arg1 = reinterpret_cast< VulkanLayerRegistrationInfo * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VulkanLayerRegistrationInfo) /* defines _wrap_delete_VulkanLayerRegistrationInfo_destructor_closure */

SWIGINTERN PyObject *_wrap_NeedVulkanLayerRegistration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VulkanLayerRegistrationInfo *arg1 = (VulkanLayerRegistrationInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_VulkanLayerRegistrationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NeedVulkanLayerRegistration" "', argument " "1"" of type '" "VulkanLayerRegistrationInfo *""'"); 
  }
  arg1 = reinterpret_cast< VulkanLayerRegistrationInfo * >(argp1);
  result = (bool)RENDERDOC_NeedVulkanLayerRegistration(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UpdateVulkanLayerRegistration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateVulkanLayerRegistration" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  RENDERDOC_UpdateVulkanLayerRegistration(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialiseReplay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GlobalEnvironment arg1 ;
  rdcarray< rdcstr > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args,"InitialiseReplay",2,2,swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GlobalEnvironment,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialiseReplay" "', argument " "1"" of type '" "GlobalEnvironment""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InitialiseReplay" "', argument " "1"" of type '" "GlobalEnvironment""'");
    } else {
      GlobalEnvironment * temp = reinterpret_cast< GlobalEnvironment * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[1], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'InitialiseReplay' argument 2 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'InitialiseReplay' argument 2 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  RENDERDOC_InitialiseReplay(arg1,(rdcarray< rdcstr > const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShutdownReplay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args,"ShutdownReplay",0,0,0)) SWIG_fail;
  RENDERDOC_ShutdownReplay();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SetDebugLogFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  rdcstr temp1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SetDebugLogFile' argument 1 of type 'rdcstr'"); 
    }
  }
  RENDERDOC_SetDebugLogFile((rdcstr const &)*arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GetLogFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GetLogFile",0,0,0)) SWIG_fail;
  result = (char *)RENDERDOC_GetLogFile();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogMessage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LogType arg1 ;
  rdcstr *arg2 = 0 ;
  rdcstr *arg3 = 0 ;
  uint32_t arg4 ;
  rdcstr *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  rdcstr temp2 ;
  rdcstr temp3 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  rdcstr temp5 ;
  PyObject *swig_obj[5] ;
  
  if (!SWIG_Python_UnpackTuple(args,"LogMessage",5,5,swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogMessage" "', argument " "1"" of type '" "LogType""'");
  } 
  arg1 = static_cast< LogType >(val1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'LogMessage' argument 2 of type 'rdcstr'"); 
    }
  }
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[2], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'LogMessage' argument 3 of type 'rdcstr'"); 
    }
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LogMessage" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  {
    tempset(arg5, &temp5);
    
    int res = ConvertFromPy(swig_obj[4], indirect(arg5));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'LogMessage' argument 5 of type 'rdcstr'"); 
    }
  }
  RENDERDOC_LogMessage(arg1,(rdcstr const &)*arg2,(rdcstr const &)*arg3,arg4,(rdcstr const &)*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GetVersionString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GetVersionString",0,0,0)) SWIG_fail;
  result = (char *)RENDERDOC_GetVersionString();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IsReleaseBuild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"IsReleaseBuild",0,0,0)) SWIG_fail;
  result = (bool)RENDERDOC_IsReleaseBuild();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GetCommitHash(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GetCommitHash",0,0,0)) SWIG_fail;
  result = (char *)RENDERDOC_GetCommitHash();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GetDriverInformation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GraphicsAPI arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  DriverInformation result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetDriverInformation" "', argument " "1"" of type '" "GraphicsAPI""'");
  } 
  arg1 = static_cast< GraphicsAPI >(val1);
  result = RENDERDOC_GetDriverInformation(arg1);
  resultobj = SWIG_NewPointerObj((new DriverInformation(static_cast< const DriverInformation& >(result))), SWIGTYPE_p_DriverInformation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GetCurrentProcessMemoryUsage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GetCurrentProcessMemoryUsage",0,0,0)) SWIG_fail;
  result = (uint64_t)RENDERDOC_GetCurrentProcessMemoryUsage();
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GetConfigSetting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  rdcstr temp1 ;
  PyObject *swig_obj[1] ;
  SDObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'GetConfigSetting' argument 1 of type 'rdcstr'"); 
    }
  }
  result = (SDObject *)RENDERDOC_GetConfigSetting((rdcstr const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SetConfigSetting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  rdcstr temp1 ;
  PyObject *swig_obj[1] ;
  SDObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SetConfigSetting' argument 1 of type 'rdcstr'"); 
    }
  }
  result = (SDObject *)RENDERDOC_SetConfigSetting((rdcstr const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SaveConfigSettings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args,"SaveConfigSettings",0,0,0)) SWIG_fail;
  RENDERDOC_SaveConfigSettings();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SetColors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatVector arg1 ;
  FloatVector arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"SetColors",3,3,swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FloatVector,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetColors" "', argument " "1"" of type '" "FloatVector""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetColors" "', argument " "1"" of type '" "FloatVector""'");
    } else {
      FloatVector * temp = reinterpret_cast< FloatVector * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FloatVector,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetColors" "', argument " "2"" of type '" "FloatVector""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetColors" "', argument " "2"" of type '" "FloatVector""'");
    } else {
      FloatVector * temp = reinterpret_cast< FloatVector * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SetColors" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  RENDERDOC_SetColors(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CheckAndroidPackage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  rdcstr *arg2 = 0 ;
  AndroidFlags *arg3 = (AndroidFlags *) 0 ;
  rdcstr temp1 ;
  rdcstr temp2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"CheckAndroidPackage",3,3,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CheckAndroidPackage' argument 1 of type 'rdcstr'"); 
    }
  }
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CheckAndroidPackage' argument 2 of type 'rdcstr'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_AndroidFlags, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CheckAndroidPackage" "', argument " "3"" of type '" "AndroidFlags *""'"); 
  }
  arg3 = reinterpret_cast< AndroidFlags * >(argp3);
  RENDERDOC_CheckAndroidPackage((rdcstr const &)*arg1,(rdcstr const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeviceProtocolController_GetProtocolName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IDeviceProtocolController *arg1 = (IDeviceProtocolController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"DeviceProtocolController_GetProtocolName",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IDeviceProtocolController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceProtocolController_GetProtocolName" "', argument " "1"" of type '" "IDeviceProtocolController *""'"); 
  }
  arg1 = reinterpret_cast< IDeviceProtocolController * >(argp1);
  result = (arg1)->GetProtocolName();
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeviceProtocolController_GetDevices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IDeviceProtocolController *arg1 = (IDeviceProtocolController *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< rdcstr > result;
  
  if (!SWIG_Python_UnpackTuple(args,"DeviceProtocolController_GetDevices",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IDeviceProtocolController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceProtocolController_GetDevices" "', argument " "1"" of type '" "IDeviceProtocolController *""'"); 
  }
  arg1 = reinterpret_cast< IDeviceProtocolController * >(argp1);
  result = (arg1)->GetDevices();
  resultobj = SWIG_NewPointerObj((new rdcarray< rdcstr >(static_cast< const rdcarray< rdcstr >& >(result))), SWIGTYPE_p_rdcarrayT_rdcstr_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeviceProtocolController_GetFriendlyName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IDeviceProtocolController *arg1 = (IDeviceProtocolController *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  rdcstr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IDeviceProtocolController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceProtocolController_GetFriendlyName" "', argument " "1"" of type '" "IDeviceProtocolController *""'"); 
  }
  arg1 = reinterpret_cast< IDeviceProtocolController * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'DeviceProtocolController_GetFriendlyName' argument 2 of type 'rdcstr'"); 
    }
  }
  result = (arg1)->GetFriendlyName((rdcstr const &)*arg2);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeviceProtocolController_SupportsMultiplePrograms(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IDeviceProtocolController *arg1 = (IDeviceProtocolController *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IDeviceProtocolController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceProtocolController_SupportsMultiplePrograms" "', argument " "1"" of type '" "IDeviceProtocolController *""'"); 
  }
  arg1 = reinterpret_cast< IDeviceProtocolController * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'DeviceProtocolController_SupportsMultiplePrograms' argument 2 of type 'rdcstr'"); 
    }
  }
  result = (bool)(arg1)->SupportsMultiplePrograms((rdcstr const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeviceProtocolController_IsSupported(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IDeviceProtocolController *arg1 = (IDeviceProtocolController *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IDeviceProtocolController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceProtocolController_IsSupported" "', argument " "1"" of type '" "IDeviceProtocolController *""'"); 
  }
  arg1 = reinterpret_cast< IDeviceProtocolController * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'DeviceProtocolController_IsSupported' argument 2 of type 'rdcstr'"); 
    }
  }
  result = (bool)(arg1)->IsSupported((rdcstr const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeviceProtocolController_StartRemoteServer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IDeviceProtocolController *arg1 = (IDeviceProtocolController *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  ResultDetails result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IDeviceProtocolController, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceProtocolController_StartRemoteServer" "', argument " "1"" of type '" "IDeviceProtocolController *""'"); 
  }
  arg1 = reinterpret_cast< IDeviceProtocolController * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'DeviceProtocolController_StartRemoteServer' argument 2 of type 'rdcstr'"); 
    }
  }
  result = (arg1)->StartRemoteServer((rdcstr const &)*arg2);
  resultobj = SWIG_NewPointerObj((new ResultDetails(static_cast< const ResultDetails& >(result))), SWIGTYPE_p_ResultDetails, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GetSupportedDeviceProtocols(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  
  {
    arg1 = new rdcarray<rdcstr>; 
  }
  if (!SWIG_Python_UnpackTuple(args,"GetSupportedDeviceProtocols",0,0,0)) SWIG_fail;
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  RENDERDOC_GetSupportedDeviceProtocols(arg1);
  resultobj = SWIG_Py_Void();
  {
    resultobj = ConvertToPy(*arg1);
    delete arg1;
  }
  {
    
  }
  return resultobj;
fail:
  {
    
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GetDeviceProtocolController(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  rdcstr temp1 ;
  PyObject *swig_obj[1] ;
  IDeviceProtocolController *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'GetDeviceProtocolController' argument 1 of type 'rdcstr'"); 
    }
  }
  result = (IDeviceProtocolController *)RENDERDOC_GetDeviceProtocolController((rdcstr const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IDeviceProtocolController, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_ResourceId__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ResourceId *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ResourceId *)new ResourceId();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ResourceId__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ResourceId *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ResourceId *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ResourceId,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ResourceId" "', argument " "1"" of type '" "ResourceId const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ResourceId" "', argument " "1"" of type '" "ResourceId const &""'"); 
  }
  arg1 = reinterpret_cast< ResourceId * >(argp1);
  result = (ResourceId *)new ResourceId((ResourceId const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ResourceId(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ResourceId",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ResourceId__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ResourceId__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ResourceId'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ResourceId::ResourceId()\n"
    "    ResourceId::ResourceId(ResourceId const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ResourceId_Null(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceId result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceId_Null",0,0,0)) SWIG_fail;
  result = ResourceId::Null();
  resultobj = SWIG_NewPointerObj((new ResourceId(static_cast< const ResourceId& >(result))), SWIGTYPE_p_ResourceId, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceId___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceId *arg1 = (ResourceId *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceId___lt__" "', argument " "1"" of type '" "ResourceId *""'"); 
  }
  arg1 = reinterpret_cast< ResourceId * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ResourceId___lt__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceId___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceId *arg1 = (ResourceId *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceId___eq__" "', argument " "1"" of type '" "ResourceId *""'"); 
  }
  arg1 = reinterpret_cast< ResourceId * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ResourceId___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceId___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceId *arg1 = (ResourceId *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceId___ne__" "', argument " "1"" of type '" "ResourceId *""'"); 
  }
  arg1 = reinterpret_cast< ResourceId * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ResourceId___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResourceId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceId *arg1 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ResourceId",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceId, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResourceId" "', argument " "1"" of type '" "ResourceId *""'"); 
  }
  arg1 = reinterpret_cast< ResourceId * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ResourceId) /* defines _wrap_delete_ResourceId_destructor_closure */

SWIGINTERN int _wrap_new_SDBasic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDBasic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_SDBasic",0,0,0)) SWIG_fail;
  result = (SDBasic *)new SDBasic();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDBasic, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_SDBasic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDBasic *arg1 = (SDBasic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_SDBasic",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDBasic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDBasic" "', argument " "1"" of type '" "SDBasic *""'"); 
  }
  arg1 = reinterpret_cast< SDBasic * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_SDBasic) /* defines _wrap_delete_SDBasic_destructor_closure */

SWIGINTERN int _wrap_new_SDTypeFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDTypeFlags *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_SDTypeFlags",0,0,0)) SWIG_fail;
  result = (SDTypeFlags *)new SDTypeFlags();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDTypeFlags, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_SDTypeFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDTypeFlags *arg1 = (SDTypeFlags *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_SDTypeFlags",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDTypeFlags, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDTypeFlags" "', argument " "1"" of type '" "SDTypeFlags *""'"); 
  }
  arg1 = reinterpret_cast< SDTypeFlags * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_SDTypeFlags) /* defines _wrap_delete_SDTypeFlags_destructor_closure */

SWIGINTERN int _wrap_new_SDChunkFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkFlags *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_SDChunkFlags",0,0,0)) SWIG_fail;
  result = (SDChunkFlags *)new SDChunkFlags();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDChunkFlags, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_SDChunkFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkFlags *arg1 = (SDChunkFlags *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_SDChunkFlags",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkFlags, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDChunkFlags" "', argument " "1"" of type '" "SDChunkFlags *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkFlags * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_SDChunkFlags) /* defines _wrap_delete_SDChunkFlags_destructor_closure */

SWIGINTERN PyObject *_wrap_SDType_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDType *arg1 = (SDType *) 0 ;
  rdcinflexiblestr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcinflexiblestr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDType_name_set" "', argument " "1"" of type '" "SDType *""'"); 
  }
  arg1 = reinterpret_cast< SDType * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SDType_name_set' argument 2 of type 'rdcinflexiblestr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDType_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDType *arg1 = (SDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcinflexiblestr result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDType_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDType_name_get" "', argument " "1"" of type '" "SDType *""'"); 
  }
  arg1 = reinterpret_cast< SDType * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDType_basetype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDType *arg1 = (SDType *) 0 ;
  SDBasic arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDType_basetype_set" "', argument " "1"" of type '" "SDType *""'"); 
  }
  arg1 = reinterpret_cast< SDType * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDType_basetype_set" "', argument " "2"" of type '" "SDBasic""'");
  } 
  arg2 = static_cast< SDBasic >(val2);
  if (arg1) (arg1)->basetype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDType_basetype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDType *arg1 = (SDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDBasic result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDType_basetype_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDType_basetype_get" "', argument " "1"" of type '" "SDType *""'"); 
  }
  arg1 = reinterpret_cast< SDType * >(argp1);
  result = (SDBasic) ((arg1)->basetype);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_SDBasic->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDType_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDType *arg1 = (SDType *) 0 ;
  SDTypeFlags arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDType_flags_set" "', argument " "1"" of type '" "SDType *""'"); 
  }
  arg1 = reinterpret_cast< SDType * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDType_flags_set" "', argument " "2"" of type '" "SDTypeFlags""'");
  } 
  arg2 = static_cast< SDTypeFlags >(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDType_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDType *arg1 = (SDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDTypeFlags result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDType_flags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDType_flags_get" "', argument " "1"" of type '" "SDType *""'"); 
  }
  arg1 = reinterpret_cast< SDType * >(argp1);
  result = (SDTypeFlags) ((arg1)->flags);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_SDTypeFlags->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDType_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDType *arg1 = (SDType *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDType_byteSize_set" "', argument " "1"" of type '" "SDType *""'"); 
  }
  arg1 = reinterpret_cast< SDType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDType_byteSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDType_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDType *arg1 = (SDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDType_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDType_byteSize_get" "', argument " "1"" of type '" "SDType *""'"); 
  }
  arg1 = reinterpret_cast< SDType * >(argp1);
  result = (uint64_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_chunkID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_chunkID_set" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDChunkMetaData_chunkID_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->chunkID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_chunkID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDChunkMetaData_chunkID_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_chunkID_get" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  result = (uint32_t) ((arg1)->chunkID);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  SDChunkFlags arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_flags_set" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDChunkMetaData_flags_set" "', argument " "2"" of type '" "SDChunkFlags""'");
  } 
  arg2 = static_cast< SDChunkFlags >(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDChunkFlags result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDChunkMetaData_flags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_flags_get" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  result = (SDChunkFlags) ((arg1)->flags);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_SDChunkFlags->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_length_set" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDChunkMetaData_length_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDChunkMetaData_length_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_length_get" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  result = (uint64_t) ((arg1)->length);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_threadID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_threadID_set" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDChunkMetaData_threadID_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->threadID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_threadID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDChunkMetaData_threadID_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_threadID_get" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  result = (uint64_t) ((arg1)->threadID);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_durationMicro_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_durationMicro_set" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDChunkMetaData_durationMicro_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = static_cast< int64_t >(val2);
  if (arg1) (arg1)->durationMicro = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_durationMicro_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDChunkMetaData_durationMicro_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_durationMicro_get" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  result = (int64_t) ((arg1)->durationMicro);
  resultobj = SWIG_From_long(static_cast< long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_timestampMicro_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_timestampMicro_set" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDChunkMetaData_timestampMicro_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->timestampMicro = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_timestampMicro_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDChunkMetaData_timestampMicro_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_timestampMicro_get" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  result = (uint64_t) ((arg1)->timestampMicro);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_callstack_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  rdcarray< uint64_t > *arg2 = (rdcarray< uint64_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_callstack_set" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'SDChunkMetaData_callstack_set' argument 2 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'SDChunkMetaData_callstack_set' argument 2 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->callstack = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunkMetaData_callstack_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunkMetaData *arg1 = (SDChunkMetaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint64_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDChunkMetaData_callstack_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunkMetaData_callstack_get" "', argument " "1"" of type '" "SDChunkMetaData *""'"); 
  }
  arg1 = reinterpret_cast< SDChunkMetaData * >(argp1);
  result = (rdcarray< uint64_t > *)& ((arg1)->callstack);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_long_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectPODData_u_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectPODData *arg1 = (SDObjectPODData *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectPODData_u_set" "', argument " "1"" of type '" "SDObjectPODData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectPODData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDObjectPODData_u_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->u = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectPODData_u_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectPODData *arg1 = (SDObjectPODData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObjectPODData_u_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectPODData_u_get" "', argument " "1"" of type '" "SDObjectPODData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectPODData * >(argp1);
  result = (uint64_t) ((arg1)->u);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectPODData_i_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectPODData *arg1 = (SDObjectPODData *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectPODData_i_set" "', argument " "1"" of type '" "SDObjectPODData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectPODData * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDObjectPODData_i_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = static_cast< int64_t >(val2);
  if (arg1) (arg1)->i = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectPODData_i_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectPODData *arg1 = (SDObjectPODData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObjectPODData_i_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectPODData_i_get" "', argument " "1"" of type '" "SDObjectPODData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectPODData * >(argp1);
  result = (int64_t) ((arg1)->i);
  resultobj = SWIG_From_long(static_cast< long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectPODData_d_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectPODData *arg1 = (SDObjectPODData *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectPODData_d_set" "', argument " "1"" of type '" "SDObjectPODData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectPODData * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDObjectPODData_d_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->d = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectPODData_d_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectPODData *arg1 = (SDObjectPODData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObjectPODData_d_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectPODData_d_get" "', argument " "1"" of type '" "SDObjectPODData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectPODData * >(argp1);
  result = (double) ((arg1)->d);
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectPODData_b_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectPODData *arg1 = (SDObjectPODData *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectPODData_b_set" "', argument " "1"" of type '" "SDObjectPODData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectPODData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDObjectPODData_b_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectPODData_b_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectPODData *arg1 = (SDObjectPODData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObjectPODData_b_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectPODData_b_get" "', argument " "1"" of type '" "SDObjectPODData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectPODData * >(argp1);
  result = (bool) ((arg1)->b);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectPODData_c_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectPODData *arg1 = (SDObjectPODData *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectPODData_c_set" "', argument " "1"" of type '" "SDObjectPODData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectPODData * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDObjectPODData_c_set" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  if (arg1) (arg1)->c = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectPODData_c_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectPODData *arg1 = (SDObjectPODData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObjectPODData_c_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectPODData_c_get" "', argument " "1"" of type '" "SDObjectPODData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectPODData * >(argp1);
  result = (char) ((arg1)->c);
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectPODData_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectPODData *arg1 = (SDObjectPODData *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectPODData_id_set" "', argument " "1"" of type '" "SDObjectPODData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectPODData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDObjectPODData_id_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->id = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectPODData_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectPODData *arg1 = (SDObjectPODData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObjectPODData_id_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectPODData_id_get" "', argument " "1"" of type '" "SDObjectPODData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectPODData * >(argp1);
  result = (ResourceId *)& ((arg1)->id);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredObjectList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredObjectList *arg1 = (StructuredObjectList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredObjectList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredObjectList_append' argument 1 of type 'StructuredObjectList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredObjectList_append' argument 1 of type 'StructuredObjectList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  result = (PyObject *)StructuredObjectList_append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredObjectList_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredObjectList *arg1 = (StructuredObjectList *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"StructuredObjectList_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredObjectList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredObjectList_clear' argument 1 of type 'StructuredObjectList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredObjectList_clear' argument 1 of type 'StructuredObjectList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  result = (PyObject *)StructuredObjectList_clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredObjectList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredObjectList *arg1 = (StructuredObjectList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"StructuredObjectList_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredObjectList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredObjectList_insert' argument 1 of type 'StructuredObjectList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredObjectList_insert' argument 1 of type 'StructuredObjectList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  result = (PyObject *)StructuredObjectList_insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredObjectList_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  StructuredObjectList *arg1 = (StructuredObjectList *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StructuredObjectList_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredObjectList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredObjectList_pop' argument 1 of type 'StructuredObjectList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredObjectList_pop' argument 1 of type 'StructuredObjectList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  result = (PyObject *)StructuredObjectList_pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredObjectList_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  StructuredObjectList *arg1 = (StructuredObjectList *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:StructuredObjectList_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredObjectList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredObjectList_sort' argument 1 of type 'StructuredObjectList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredObjectList_sort' argument 1 of type 'StructuredObjectList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StructuredObjectList_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  result = (PyObject *)StructuredObjectList_sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredObjectList_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredObjectList *arg1 = (StructuredObjectList *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"StructuredObjectList_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredObjectList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredObjectList_copy' argument 1 of type 'StructuredObjectList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredObjectList_copy' argument 1 of type 'StructuredObjectList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  result = (PyObject *)StructuredObjectList_copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredObjectList_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredObjectList *arg1 = (StructuredObjectList *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"StructuredObjectList_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredObjectList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredObjectList_reverse' argument 1 of type 'StructuredObjectList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredObjectList_reverse' argument 1 of type 'StructuredObjectList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  result = (PyObject *)StructuredObjectList_reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredObjectList_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  StructuredObjectList *arg1 = (StructuredObjectList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:StructuredObjectList_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredObjectList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredObjectList_index' argument 1 of type 'StructuredObjectList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredObjectList_index' argument 1 of type 'StructuredObjectList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  result = (PyObject *)StructuredObjectList_index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredObjectList_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredObjectList *arg1 = (StructuredObjectList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredObjectList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredObjectList_count' argument 1 of type 'StructuredObjectList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredObjectList_count' argument 1 of type 'StructuredObjectList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  result = (PyObject *)StructuredObjectList_count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredObjectList_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredObjectList *arg1 = (StructuredObjectList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredObjectList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredObjectList_extend' argument 1 of type 'StructuredObjectList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredObjectList_extend' argument 1 of type 'StructuredObjectList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  result = (PyObject *)StructuredObjectList_extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredObjectList_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredObjectList *arg1 = (StructuredObjectList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredObjectList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredObjectList_remove' argument 1 of type 'StructuredObjectList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredObjectList_remove' argument 1 of type 'StructuredObjectList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  result = (PyObject *)StructuredObjectList_remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectData_basic_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectData *arg1 = (SDObjectData *) 0 ;
  SDObjectPODData *arg2 = (SDObjectPODData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectData_basic_set" "', argument " "1"" of type '" "SDObjectData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDObjectData_basic_set" "', argument " "2"" of type '" "SDObjectPODData *""'"); 
  }
  arg2 = reinterpret_cast< SDObjectPODData * >(argp2);
  if (arg1) (arg1)->basic = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectData_basic_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectData *arg1 = (SDObjectData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDObjectPODData *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObjectData_basic_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectData_basic_get" "', argument " "1"" of type '" "SDObjectData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectData * >(argp1);
  result = (SDObjectPODData *)& ((arg1)->basic);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObjectPODData, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectData_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectData *arg1 = (SDObjectData *) 0 ;
  rdcinflexiblestr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcinflexiblestr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectData_string_set" "', argument " "1"" of type '" "SDObjectData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectData * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SDObjectData_string_set' argument 2 of type 'rdcinflexiblestr'"); 
    }
  }
  if (arg1) (arg1)->str = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObjectData_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObjectData *arg1 = (SDObjectData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcinflexiblestr result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObjectData_string_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObjectData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObjectData_string_get" "', argument " "1"" of type '" "SDObjectData *""'"); 
  }
  arg1 = reinterpret_cast< SDObjectData * >(argp1);
  result =  ((arg1)->str);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_SDObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcinflexiblestr *arg1 = 0 ;
  rdcinflexiblestr *arg2 = 0 ;
  rdcinflexiblestr temp1 ;
  rdcinflexiblestr temp2 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_SDObject",2,2,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_SDObject' argument 1 of type 'rdcinflexiblestr'"); 
    }
  }
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_SDObject' argument 2 of type 'rdcinflexiblestr'"); 
    }
  }
  result = (SDObject *)new SDObject((rdcinflexiblestr const &)*arg1,(rdcinflexiblestr const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_SDObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_SDObject",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDObject" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_Duplicate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObject_Duplicate",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_Duplicate" "', argument " "1"" of type '" "SDObject const *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  result = (SDObject *)((SDObject const *)arg1)->Duplicate();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  rdcinflexiblestr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcinflexiblestr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_name_set" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SDObject_name_set' argument 2 of type 'rdcinflexiblestr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcinflexiblestr result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObject_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_name_get" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObject_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_type_get" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  result = (SDType *)& ((arg1)->type);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDType, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDObjectData *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObject_data_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_data_get" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  result = (SDObjectData *)& ((arg1)->data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObjectData, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_HasEqualValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  SDObject *arg2 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_HasEqualValue" "', argument " "1"" of type '" "SDObject const *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDObject_HasEqualValue" "', argument " "2"" of type '" "SDObject const *""'"); 
  }
  arg2 = reinterpret_cast< SDObject * >(argp2);
  result = (bool)((SDObject const *)arg1)->HasEqualValue((SDObject const *)arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_AddChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  SDObject *arg2 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_AddChild" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDObject_AddChild" "', argument " "2"" of type '" "SDObject const *""'"); 
  }
  arg2 = reinterpret_cast< SDObject * >(argp2);
  (arg1)->DuplicateAndAddChild((SDObject const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_FindChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_FindChild" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SDObject_FindChild' argument 2 of type 'rdcstr'"); 
    }
  }
  result = (SDObject *)(arg1)->FindChild((rdcstr const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_FindChildRecursively(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_FindChildRecursively" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SDObject_FindChildRecursively' argument 2 of type 'rdcstr'"); 
    }
  }
  result = (SDObject *)(arg1)->FindChildRecursively((rdcstr const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_CreateChildByKeyPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_CreateChildByKeyPath" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SDObject_CreateChildByKeyPath' argument 2 of type 'rdcstr'"); 
    }
  }
  result = (SDObject *)(arg1)->CreateChildByKeyPath((rdcstr const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_FindChildByKeyPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_FindChildByKeyPath" "', argument " "1"" of type '" "SDObject const *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SDObject_FindChildByKeyPath' argument 2 of type 'rdcstr'"); 
    }
  }
  result = (SDObject *)((SDObject const *)arg1)->FindChildByKeyPath((rdcstr const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_EraseChildByKeyPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_EraseChildByKeyPath" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SDObject_EraseChildByKeyPath' argument 2 of type 'rdcstr'"); 
    }
  }
  (arg1)->EraseChildByKeyPath((rdcstr const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_GetChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_GetChild" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDObject_GetChild" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (SDObject *)(arg1)->GetChild(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_GetParent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObject_GetParent",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_GetParent" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  result = (SDObject *)(arg1)->GetParent();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_RemoveChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_RemoveChild" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDObject_RemoveChild" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->RemoveChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_DeleteChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObject_DeleteChildren",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_DeleteChildren" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  (arg1)->DeleteChildren();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_NumChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObject_NumChildren",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_NumChildren" "', argument " "1"" of type '" "SDObject const *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  result = ((SDObject const *)arg1)->NumChildren();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_AsBool(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObject_AsBool",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_AsBool" "', argument " "1"" of type '" "SDObject const *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  result = (bool)((SDObject const *)arg1)->AsBool();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_AsResourceId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObject_AsResourceId",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_AsResourceId" "', argument " "1"" of type '" "SDObject const *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  result = ((SDObject const *)arg1)->AsResourceId();
  resultobj = SWIG_NewPointerObj((new ResourceId(static_cast< const ResourceId& >(result))), SWIGTYPE_p_ResourceId, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_AsInt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObject_AsInt",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_AsInt" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  result = (PyObject *)SDObject_AsInt(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_AsFloat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObject_AsFloat",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_AsFloat" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  result = (PyObject *)SDObject_AsFloat(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDObject_AsString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDObject *arg1 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDObject_AsString",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDObject_AsString" "', argument " "1"" of type '" "SDObject *""'"); 
  }
  arg1 = reinterpret_cast< SDObject * >(argp1);
  result = (PyObject *)SDObject_AsString(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_makeSDInt64(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcinflexiblestr *arg1 = 0 ;
  int64_t arg2 ;
  rdcinflexiblestr temp1 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"makeSDInt64",2,2,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'makeSDInt64' argument 1 of type 'rdcinflexiblestr'"); 
    }
  }
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "makeSDInt64" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = static_cast< int64_t >(val2);
  result = (SDObject *)makeSDInt64((rdcinflexiblestr const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_makeSDUInt64(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcinflexiblestr *arg1 = 0 ;
  uint64_t arg2 ;
  rdcinflexiblestr temp1 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"makeSDUInt64",2,2,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'makeSDUInt64' argument 1 of type 'rdcinflexiblestr'"); 
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "makeSDUInt64" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  result = (SDObject *)makeSDUInt64((rdcinflexiblestr const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_makeSDInt32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcinflexiblestr *arg1 = 0 ;
  int32_t arg2 ;
  rdcinflexiblestr temp1 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"makeSDInt32",2,2,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'makeSDInt32' argument 1 of type 'rdcinflexiblestr'"); 
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "makeSDInt32" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  result = (SDObject *)makeSDInt32((rdcinflexiblestr const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_makeSDUInt32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcinflexiblestr *arg1 = 0 ;
  uint32_t arg2 ;
  rdcinflexiblestr temp1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"makeSDUInt32",2,2,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'makeSDUInt32' argument 1 of type 'rdcinflexiblestr'"); 
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "makeSDUInt32" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  result = (SDObject *)makeSDUInt32((rdcinflexiblestr const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_makeSDFloat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcinflexiblestr *arg1 = 0 ;
  float arg2 ;
  rdcinflexiblestr temp1 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"makeSDFloat",2,2,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'makeSDFloat' argument 1 of type 'rdcinflexiblestr'"); 
    }
  }
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "makeSDFloat" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SDObject *)makeSDFloat((rdcinflexiblestr const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_makeSDBool(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcinflexiblestr *arg1 = 0 ;
  bool arg2 ;
  rdcinflexiblestr temp1 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"makeSDBool",2,2,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'makeSDBool' argument 1 of type 'rdcinflexiblestr'"); 
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "makeSDBool" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (SDObject *)makeSDBool((rdcinflexiblestr const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_makeSDString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcinflexiblestr *arg1 = 0 ;
  rdcstr *arg2 = 0 ;
  rdcinflexiblestr temp1 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"makeSDString",2,2,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'makeSDString' argument 1 of type 'rdcinflexiblestr'"); 
    }
  }
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'makeSDString' argument 2 of type 'rdcstr'"); 
    }
  }
  result = (SDObject *)makeSDString((rdcinflexiblestr const &)*arg1,(rdcstr const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_makeSDResourceId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcinflexiblestr *arg1 = 0 ;
  ResourceId arg2 ;
  rdcinflexiblestr temp1 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"makeSDResourceId",2,2,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'makeSDResourceId' argument 1 of type 'rdcinflexiblestr'"); 
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "makeSDResourceId" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "makeSDResourceId" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SDObject *)makeSDResourceId((rdcinflexiblestr const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_makeSDEnum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcinflexiblestr *arg1 = 0 ;
  uint32_t arg2 ;
  rdcinflexiblestr temp1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"makeSDEnum",2,2,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'makeSDEnum' argument 1 of type 'rdcinflexiblestr'"); 
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "makeSDEnum" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  result = (SDObject *)makeSDEnum((rdcinflexiblestr const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_makeSDArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcinflexiblestr *arg1 = 0 ;
  rdcinflexiblestr temp1 ;
  PyObject *swig_obj[1] ;
  SDObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'makeSDArray' argument 1 of type 'rdcinflexiblestr'"); 
    }
  }
  result = (SDObject *)makeSDArray((rdcinflexiblestr const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_makeSDStruct(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcinflexiblestr *arg1 = 0 ;
  rdcinflexiblestr *arg2 = 0 ;
  rdcinflexiblestr temp1 ;
  rdcinflexiblestr temp2 ;
  PyObject *swig_obj[2] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"makeSDStruct",2,2,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'makeSDStruct' argument 1 of type 'rdcinflexiblestr'"); 
    }
  }
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'makeSDStruct' argument 2 of type 'rdcinflexiblestr'"); 
    }
  }
  result = (SDObject *)makeSDStruct((rdcinflexiblestr const &)*arg1,(rdcinflexiblestr const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_SDChunk(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcinflexiblestr *arg1 = 0 ;
  rdcinflexiblestr temp1 ;
  PyObject *swig_obj[1] ;
  SDChunk *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_SDChunk",1,1,swig_obj)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_SDChunk' argument 1 of type 'rdcinflexiblestr'"); 
    }
  }
  result = (SDChunk *)new SDChunk((rdcinflexiblestr const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDChunk, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_SDChunk_metadata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunk *arg1 = (SDChunk *) 0 ;
  SDChunkMetaData *arg2 = (SDChunkMetaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunk_metadata_set" "', argument " "1"" of type '" "SDChunk *""'"); 
  }
  arg1 = reinterpret_cast< SDChunk * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDChunk_metadata_set" "', argument " "2"" of type '" "SDChunkMetaData *""'"); 
  }
  arg2 = reinterpret_cast< SDChunkMetaData * >(argp2);
  if (arg1) (arg1)->metadata = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunk_metadata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunk *arg1 = (SDChunk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDChunkMetaData *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDChunk_metadata_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunk_metadata_get" "', argument " "1"" of type '" "SDChunk *""'"); 
  }
  arg1 = reinterpret_cast< SDChunk * >(argp1);
  result = (SDChunkMetaData *)& ((arg1)->metadata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDChunkMetaData, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDChunk_Duplicate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunk *arg1 = (SDChunk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDChunk *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDChunk_Duplicate",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDChunk_Duplicate" "', argument " "1"" of type '" "SDChunk const *""'"); 
  }
  arg1 = reinterpret_cast< SDChunk * >(argp1);
  result = (SDChunk *)((SDChunk const *)arg1)->Duplicate();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDChunk, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SDChunk(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDChunk *arg1 = (SDChunk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_SDChunk",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDChunk, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDChunk" "', argument " "1"" of type '" "SDChunk *""'"); 
  }
  arg1 = reinterpret_cast< SDChunk * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredChunkList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredChunkList *arg1 = (StructuredChunkList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredChunkList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredChunkList_append' argument 1 of type 'StructuredChunkList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredChunkList_append' argument 1 of type 'StructuredChunkList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  result = (PyObject *)StructuredChunkList_append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredChunkList_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredChunkList *arg1 = (StructuredChunkList *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"StructuredChunkList_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredChunkList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredChunkList_clear' argument 1 of type 'StructuredChunkList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredChunkList_clear' argument 1 of type 'StructuredChunkList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  result = (PyObject *)StructuredChunkList_clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredChunkList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredChunkList *arg1 = (StructuredChunkList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"StructuredChunkList_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredChunkList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredChunkList_insert' argument 1 of type 'StructuredChunkList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredChunkList_insert' argument 1 of type 'StructuredChunkList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  result = (PyObject *)StructuredChunkList_insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredChunkList_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  StructuredChunkList *arg1 = (StructuredChunkList *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StructuredChunkList_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredChunkList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredChunkList_pop' argument 1 of type 'StructuredChunkList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredChunkList_pop' argument 1 of type 'StructuredChunkList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  result = (PyObject *)StructuredChunkList_pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredChunkList_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  StructuredChunkList *arg1 = (StructuredChunkList *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:StructuredChunkList_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredChunkList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredChunkList_sort' argument 1 of type 'StructuredChunkList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredChunkList_sort' argument 1 of type 'StructuredChunkList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StructuredChunkList_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  result = (PyObject *)StructuredChunkList_sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredChunkList_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredChunkList *arg1 = (StructuredChunkList *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"StructuredChunkList_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredChunkList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredChunkList_copy' argument 1 of type 'StructuredChunkList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredChunkList_copy' argument 1 of type 'StructuredChunkList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  result = (PyObject *)StructuredChunkList_copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredChunkList_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredChunkList *arg1 = (StructuredChunkList *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"StructuredChunkList_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredChunkList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredChunkList_reverse' argument 1 of type 'StructuredChunkList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredChunkList_reverse' argument 1 of type 'StructuredChunkList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  result = (PyObject *)StructuredChunkList_reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredChunkList_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  StructuredChunkList *arg1 = (StructuredChunkList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:StructuredChunkList_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredChunkList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredChunkList_index' argument 1 of type 'StructuredChunkList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredChunkList_index' argument 1 of type 'StructuredChunkList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  result = (PyObject *)StructuredChunkList_index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredChunkList_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredChunkList *arg1 = (StructuredChunkList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredChunkList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredChunkList_count' argument 1 of type 'StructuredChunkList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredChunkList_count' argument 1 of type 'StructuredChunkList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  result = (PyObject *)StructuredChunkList_count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredChunkList_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredChunkList *arg1 = (StructuredChunkList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredChunkList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredChunkList_extend' argument 1 of type 'StructuredChunkList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredChunkList_extend' argument 1 of type 'StructuredChunkList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  result = (PyObject *)StructuredChunkList_extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredChunkList_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredChunkList *arg1 = (StructuredChunkList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredChunkList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredChunkList_remove' argument 1 of type 'StructuredChunkList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredChunkList_remove' argument 1 of type 'StructuredChunkList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  result = (PyObject *)StructuredChunkList_remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredBufferList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredBufferList *arg1 = (StructuredBufferList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredBufferList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredBufferList_append' argument 1 of type 'StructuredBufferList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredBufferList_append' argument 1 of type 'StructuredBufferList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  result = (PyObject *)StructuredBufferList_append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredBufferList_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredBufferList *arg1 = (StructuredBufferList *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"StructuredBufferList_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredBufferList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredBufferList_clear' argument 1 of type 'StructuredBufferList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredBufferList_clear' argument 1 of type 'StructuredBufferList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  result = (PyObject *)StructuredBufferList_clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredBufferList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredBufferList *arg1 = (StructuredBufferList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"StructuredBufferList_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredBufferList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredBufferList_insert' argument 1 of type 'StructuredBufferList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredBufferList_insert' argument 1 of type 'StructuredBufferList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  result = (PyObject *)StructuredBufferList_insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredBufferList_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  StructuredBufferList *arg1 = (StructuredBufferList *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StructuredBufferList_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredBufferList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredBufferList_pop' argument 1 of type 'StructuredBufferList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredBufferList_pop' argument 1 of type 'StructuredBufferList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  result = (PyObject *)StructuredBufferList_pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredBufferList_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  StructuredBufferList *arg1 = (StructuredBufferList *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:StructuredBufferList_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredBufferList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredBufferList_sort' argument 1 of type 'StructuredBufferList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredBufferList_sort' argument 1 of type 'StructuredBufferList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StructuredBufferList_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  result = (PyObject *)StructuredBufferList_sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredBufferList_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredBufferList *arg1 = (StructuredBufferList *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"StructuredBufferList_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredBufferList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredBufferList_copy' argument 1 of type 'StructuredBufferList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredBufferList_copy' argument 1 of type 'StructuredBufferList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  result = (PyObject *)StructuredBufferList_copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredBufferList_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredBufferList *arg1 = (StructuredBufferList *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"StructuredBufferList_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredBufferList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredBufferList_reverse' argument 1 of type 'StructuredBufferList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredBufferList_reverse' argument 1 of type 'StructuredBufferList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  result = (PyObject *)StructuredBufferList_reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredBufferList_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  StructuredBufferList *arg1 = (StructuredBufferList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:StructuredBufferList_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredBufferList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredBufferList_index' argument 1 of type 'StructuredBufferList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredBufferList_index' argument 1 of type 'StructuredBufferList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  result = (PyObject *)StructuredBufferList_index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredBufferList_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredBufferList *arg1 = (StructuredBufferList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredBufferList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredBufferList_count' argument 1 of type 'StructuredBufferList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredBufferList_count' argument 1 of type 'StructuredBufferList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  result = (PyObject *)StructuredBufferList_count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredBufferList_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredBufferList *arg1 = (StructuredBufferList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredBufferList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredBufferList_extend' argument 1 of type 'StructuredBufferList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredBufferList_extend' argument 1 of type 'StructuredBufferList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  result = (PyObject *)StructuredBufferList_extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_StructuredBufferList_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StructuredBufferList *arg1 = (StructuredBufferList *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for StructuredBufferList");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'StructuredBufferList_remove' argument 1 of type 'StructuredBufferList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'StructuredBufferList_remove' argument 1 of type 'StructuredBufferList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  result = (PyObject *)StructuredBufferList_remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN int _wrap_new_SDFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDFile *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_SDFile",0,0,0)) SWIG_fail;
  result = (SDFile *)new SDFile();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDFile, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_SDFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDFile *arg1 = (SDFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_SDFile",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDFile, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDFile" "', argument " "1"" of type '" "SDFile *""'"); 
  }
  arg1 = reinterpret_cast< SDFile * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDFile_chunks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDFile *arg1 = (SDFile *) 0 ;
  StructuredChunkList *arg2 = (StructuredChunkList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDFile_chunks_set" "', argument " "1"" of type '" "SDFile *""'"); 
  }
  arg1 = reinterpret_cast< SDFile * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for StructuredChunkList");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'SDFile_chunks_set' argument 2 of type 'StructuredChunkList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'SDFile_chunks_set' argument 2 of type 'StructuredChunkList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    // remove a reference on all the old items
    for(size_t i = 0; i < (&arg1->chunks)->size(); i++)
    ExtRefcount<StructuredChunkList::value_type>::Dec(arg1->chunks[i]);
    
    (&arg1->chunks)->clear();
    
    // copy the values
    (&arg1->chunks)->assign(*arg2);
    
    // the input values were already ref'd as needed during the 'in' typemap to convert them in the
    // first place, so we just steal those references
  }
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDFile_chunks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDFile *arg1 = (SDFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StructuredChunkList *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDFile_chunks_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDFile_chunks_get" "', argument " "1"" of type '" "SDFile *""'"); 
  }
  arg1 = reinterpret_cast< SDFile * >(argp1);
  result = (StructuredChunkList *)& ((arg1)->chunks);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StructuredChunkList, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDFile_buffers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDFile *arg1 = (SDFile *) 0 ;
  StructuredBufferList *arg2 = (StructuredBufferList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDFile_buffers_set" "', argument " "1"" of type '" "SDFile *""'"); 
  }
  arg1 = reinterpret_cast< SDFile * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for StructuredBufferList");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'SDFile_buffers_set' argument 2 of type 'StructuredBufferList'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'SDFile_buffers_set' argument 2 of type 'StructuredBufferList', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    // delete old byte arrays
    for(size_t i=0; i < (&arg1->buffers)->size(); i++)
    delete arg1->buffers[i];
    
    // copy the values
    (&arg1->buffers)->assign(*arg2);
  }
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDFile_buffers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDFile *arg1 = (SDFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StructuredBufferList *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDFile_buffers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDFile_buffers_get" "', argument " "1"" of type '" "SDFile *""'"); 
  }
  arg1 = reinterpret_cast< SDFile * >(argp1);
  result = (StructuredBufferList *)& ((arg1)->buffers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StructuredBufferList, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDFile_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDFile *arg1 = (SDFile *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDFile_version_set" "', argument " "1"" of type '" "SDFile *""'"); 
  }
  arg1 = reinterpret_cast< SDFile * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SDFile_version_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDFile_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDFile *arg1 = (SDFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SDFile_version_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDFile_version_get" "', argument " "1"" of type '" "SDFile *""'"); 
  }
  arg1 = reinterpret_cast< SDFile * >(argp1);
  result = (uint64_t) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDFile_Swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDFile *arg1 = (SDFile *) 0 ;
  SDFile *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDFile_Swap" "', argument " "1"" of type '" "SDFile *""'"); 
  }
  arg1 = reinterpret_cast< SDFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_SDFile,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDFile_Swap" "', argument " "2"" of type '" "SDFile &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDFile_Swap" "', argument " "2"" of type '" "SDFile &""'"); 
  }
  arg2 = reinterpret_cast< SDFile * >(argp2);
  (arg1)->Swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SDFile_Detach(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SDFile *arg1 = (SDFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"SDFile_Detach",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SDFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDFile_Detach" "', argument " "1"" of type '" "SDFile *""'"); 
  }
  arg1 = reinterpret_cast< SDFile * >(argp1);
  (arg1)->Detach();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_EncodeAsString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureOptions_EncodeAsString",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_EncodeAsString" "', argument " "1"" of type '" "CaptureOptions const *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  result = ((CaptureOptions const *)arg1)->EncodeAsString();
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_DecodeFromString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_DecodeFromString" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureOptions_DecodeFromString' argument 2 of type 'rdcstr'"); 
    }
  }
  (arg1)->DecodeFromString((rdcstr const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_allowVSync_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_allowVSync_set" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureOptions_allowVSync_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->allowVSync = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_allowVSync_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureOptions_allowVSync_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_allowVSync_get" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  result = (bool) ((arg1)->allowVSync);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_allowFullscreen_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_allowFullscreen_set" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureOptions_allowFullscreen_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->allowFullscreen = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_allowFullscreen_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureOptions_allowFullscreen_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_allowFullscreen_get" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  result = (bool) ((arg1)->allowFullscreen);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_apiValidation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_apiValidation_set" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureOptions_apiValidation_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->apiValidation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_apiValidation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureOptions_apiValidation_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_apiValidation_get" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  result = (bool) ((arg1)->apiValidation);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_captureCallstacks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_captureCallstacks_set" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureOptions_captureCallstacks_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->captureCallstacks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_captureCallstacks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureOptions_captureCallstacks_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_captureCallstacks_get" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  result = (bool) ((arg1)->captureCallstacks);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_captureCallstacksOnlyActions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_captureCallstacksOnlyActions_set" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureOptions_captureCallstacksOnlyActions_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->captureCallstacksOnlyActions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_captureCallstacksOnlyActions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureOptions_captureCallstacksOnlyActions_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_captureCallstacksOnlyActions_get" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  result = (bool) ((arg1)->captureCallstacksOnlyActions);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_delayForDebugger_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_delayForDebugger_set" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureOptions_delayForDebugger_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->delayForDebugger = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_delayForDebugger_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureOptions_delayForDebugger_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_delayForDebugger_get" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  result = (uint32_t) ((arg1)->delayForDebugger);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_verifyBufferAccess_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_verifyBufferAccess_set" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureOptions_verifyBufferAccess_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->verifyBufferAccess = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_verifyBufferAccess_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureOptions_verifyBufferAccess_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_verifyBufferAccess_get" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  result = (bool) ((arg1)->verifyBufferAccess);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_hookIntoChildren_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_hookIntoChildren_set" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureOptions_hookIntoChildren_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->hookIntoChildren = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_hookIntoChildren_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureOptions_hookIntoChildren_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_hookIntoChildren_get" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  result = (bool) ((arg1)->hookIntoChildren);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_refAllResources_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_refAllResources_set" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureOptions_refAllResources_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->refAllResources = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_refAllResources_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureOptions_refAllResources_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_refAllResources_get" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  result = (bool) ((arg1)->refAllResources);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_captureAllCmdLists_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_captureAllCmdLists_set" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureOptions_captureAllCmdLists_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->captureAllCmdLists = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_captureAllCmdLists_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureOptions_captureAllCmdLists_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_captureAllCmdLists_get" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  result = (bool) ((arg1)->captureAllCmdLists);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_debugOutputMute_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_debugOutputMute_set" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureOptions_debugOutputMute_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->debugOutputMute = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_debugOutputMute_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureOptions_debugOutputMute_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_debugOutputMute_get" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  result = (bool) ((arg1)->debugOutputMute);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_softMemoryLimit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_softMemoryLimit_set" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureOptions_softMemoryLimit_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->softMemoryLimit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureOptions_softMemoryLimit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureOptions_softMemoryLimit_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureOptions_softMemoryLimit_get" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  result = (uint32_t) ((arg1)->softMemoryLimit);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_CaptureOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_CaptureOptions",0,0,0)) SWIG_fail;
  result = (CaptureOptions *)new CaptureOptions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CaptureOptions, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_CaptureOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureOptions *arg1 = (CaptureOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_CaptureOptions",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CaptureOptions" "', argument " "1"" of type '" "CaptureOptions *""'"); 
  }
  arg1 = reinterpret_cast< CaptureOptions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CaptureOptions) /* defines _wrap_delete_CaptureOptions_destructor_closure */

SWIGINTERN PyObject *_wrap_TaskGroupSize_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TaskGroupSize *arg1 = (TaskGroupSize *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TaskGroupSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TaskGroupSize_x_set" "', argument " "1"" of type '" "TaskGroupSize *""'"); 
  }
  arg1 = reinterpret_cast< TaskGroupSize * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TaskGroupSize_x_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TaskGroupSize_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TaskGroupSize *arg1 = (TaskGroupSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TaskGroupSize_x_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TaskGroupSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TaskGroupSize_x_get" "', argument " "1"" of type '" "TaskGroupSize *""'"); 
  }
  arg1 = reinterpret_cast< TaskGroupSize * >(argp1);
  result = (uint32_t) ((arg1)->x);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TaskGroupSize_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TaskGroupSize *arg1 = (TaskGroupSize *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TaskGroupSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TaskGroupSize_y_set" "', argument " "1"" of type '" "TaskGroupSize *""'"); 
  }
  arg1 = reinterpret_cast< TaskGroupSize * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TaskGroupSize_y_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TaskGroupSize_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TaskGroupSize *arg1 = (TaskGroupSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TaskGroupSize_y_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TaskGroupSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TaskGroupSize_y_get" "', argument " "1"" of type '" "TaskGroupSize *""'"); 
  }
  arg1 = reinterpret_cast< TaskGroupSize * >(argp1);
  result = (uint32_t) ((arg1)->y);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TaskGroupSize_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TaskGroupSize *arg1 = (TaskGroupSize *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TaskGroupSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TaskGroupSize_z_set" "', argument " "1"" of type '" "TaskGroupSize *""'"); 
  }
  arg1 = reinterpret_cast< TaskGroupSize * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TaskGroupSize_z_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TaskGroupSize_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TaskGroupSize *arg1 = (TaskGroupSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TaskGroupSize_z_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TaskGroupSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TaskGroupSize_z_get" "', argument " "1"" of type '" "TaskGroupSize *""'"); 
  }
  arg1 = reinterpret_cast< TaskGroupSize * >(argp1);
  result = (uint32_t) ((arg1)->z);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TaskGroupSize___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TaskGroupSize *arg1 = (TaskGroupSize *) 0 ;
  TaskGroupSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TaskGroupSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TaskGroupSize___eq__" "', argument " "1"" of type '" "TaskGroupSize const *""'"); 
  }
  arg1 = reinterpret_cast< TaskGroupSize * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_TaskGroupSize,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TaskGroupSize___eq__" "', argument " "2"" of type '" "TaskGroupSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TaskGroupSize___eq__" "', argument " "2"" of type '" "TaskGroupSize const &""'"); 
  }
  arg2 = reinterpret_cast< TaskGroupSize * >(argp2);
  result = (bool)((TaskGroupSize const *)arg1)->operator ==((TaskGroupSize const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TaskGroupSize___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TaskGroupSize *arg1 = (TaskGroupSize *) 0 ;
  TaskGroupSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TaskGroupSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TaskGroupSize___lt__" "', argument " "1"" of type '" "TaskGroupSize const *""'"); 
  }
  arg1 = reinterpret_cast< TaskGroupSize * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_TaskGroupSize,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TaskGroupSize___lt__" "', argument " "2"" of type '" "TaskGroupSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TaskGroupSize___lt__" "', argument " "2"" of type '" "TaskGroupSize const &""'"); 
  }
  arg2 = reinterpret_cast< TaskGroupSize * >(argp2);
  result = (bool)((TaskGroupSize const *)arg1)->operator <((TaskGroupSize const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_TaskGroupSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TaskGroupSize *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_TaskGroupSize",0,0,0)) SWIG_fail;
  result = (TaskGroupSize *)new TaskGroupSize();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TaskGroupSize, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_TaskGroupSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TaskGroupSize *arg1 = (TaskGroupSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TaskGroupSize",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TaskGroupSize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TaskGroupSize" "', argument " "1"" of type '" "TaskGroupSize *""'"); 
  }
  arg1 = reinterpret_cast< TaskGroupSize * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TaskGroupSize) /* defines _wrap_delete_TaskGroupSize_destructor_closure */

SWIGINTERN PyObject *_wrap_MeshletSize_numIndices_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshletSize *arg1 = (MeshletSize *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshletSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshletSize_numIndices_set" "', argument " "1"" of type '" "MeshletSize *""'"); 
  }
  arg1 = reinterpret_cast< MeshletSize * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshletSize_numIndices_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->numIndices = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshletSize_numIndices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshletSize *arg1 = (MeshletSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshletSize_numIndices_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshletSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshletSize_numIndices_get" "', argument " "1"" of type '" "MeshletSize *""'"); 
  }
  arg1 = reinterpret_cast< MeshletSize * >(argp1);
  result = (uint32_t) ((arg1)->numIndices);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshletSize_numVertices_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshletSize *arg1 = (MeshletSize *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshletSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshletSize_numVertices_set" "', argument " "1"" of type '" "MeshletSize *""'"); 
  }
  arg1 = reinterpret_cast< MeshletSize * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshletSize_numVertices_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->numVertices = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshletSize_numVertices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshletSize *arg1 = (MeshletSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshletSize_numVertices_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshletSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshletSize_numVertices_get" "', argument " "1"" of type '" "MeshletSize *""'"); 
  }
  arg1 = reinterpret_cast< MeshletSize * >(argp1);
  result = (uint32_t) ((arg1)->numVertices);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshletSize___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshletSize *arg1 = (MeshletSize *) 0 ;
  MeshletSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshletSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshletSize___eq__" "', argument " "1"" of type '" "MeshletSize const *""'"); 
  }
  arg1 = reinterpret_cast< MeshletSize * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_MeshletSize,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshletSize___eq__" "', argument " "2"" of type '" "MeshletSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MeshletSize___eq__" "', argument " "2"" of type '" "MeshletSize const &""'"); 
  }
  arg2 = reinterpret_cast< MeshletSize * >(argp2);
  result = (bool)((MeshletSize const *)arg1)->operator ==((MeshletSize const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshletSize___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshletSize *arg1 = (MeshletSize *) 0 ;
  MeshletSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshletSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshletSize___lt__" "', argument " "1"" of type '" "MeshletSize const *""'"); 
  }
  arg1 = reinterpret_cast< MeshletSize * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_MeshletSize,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshletSize___lt__" "', argument " "2"" of type '" "MeshletSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MeshletSize___lt__" "', argument " "2"" of type '" "MeshletSize const &""'"); 
  }
  arg2 = reinterpret_cast< MeshletSize * >(argp2);
  result = (bool)((MeshletSize const *)arg1)->operator <((MeshletSize const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_MeshletSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshletSize *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_MeshletSize",0,0,0)) SWIG_fail;
  result = (MeshletSize *)new MeshletSize();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MeshletSize, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_MeshletSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshletSize *arg1 = (MeshletSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_MeshletSize",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshletSize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MeshletSize" "', argument " "1"" of type '" "MeshletSize *""'"); 
  }
  arg1 = reinterpret_cast< MeshletSize * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_MeshletSize) /* defines _wrap_delete_MeshletSize_destructor_closure */

SWIGINTERN int _wrap_new_MeshFormat__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  MeshFormat *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (MeshFormat *)new MeshFormat();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MeshFormat, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_MeshFormat__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  MeshFormat *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_MeshFormat,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MeshFormat" "', argument " "1"" of type '" "MeshFormat const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MeshFormat" "', argument " "1"" of type '" "MeshFormat const &""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (MeshFormat *)new MeshFormat((MeshFormat const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MeshFormat, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_MeshFormat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_MeshFormat",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MeshFormat__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_MeshFormat__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MeshFormat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MeshFormat::MeshFormat()\n"
    "    MeshFormat::MeshFormat(MeshFormat const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_MeshFormat_indexResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_indexResourceId_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshFormat_indexResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->indexResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_indexResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_indexResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_indexResourceId_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (ResourceId *)& ((arg1)->indexResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_indexByteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_indexByteOffset_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_indexByteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->indexByteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_indexByteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_indexByteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_indexByteOffset_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (uint64_t) ((arg1)->indexByteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_indexByteStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_indexByteStride_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_indexByteStride_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->indexByteStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_indexByteStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_indexByteStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_indexByteStride_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (uint32_t) ((arg1)->indexByteStride);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_indexByteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_indexByteSize_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_indexByteSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->indexByteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_indexByteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_indexByteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_indexByteSize_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (uint64_t) ((arg1)->indexByteSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_baseVertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_baseVertex_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_baseVertex_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->baseVertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_baseVertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_baseVertex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_baseVertex_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (int32_t) ((arg1)->baseVertex);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_vertexResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_vertexResourceId_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshFormat_vertexResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->vertexResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_vertexResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_vertexResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_vertexResourceId_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (ResourceId *)& ((arg1)->vertexResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_vertexByteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_vertexByteOffset_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_vertexByteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->vertexByteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_vertexByteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_vertexByteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_vertexByteOffset_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (uint64_t) ((arg1)->vertexByteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_vertexByteStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_vertexByteStride_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_vertexByteStride_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->vertexByteStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_vertexByteStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_vertexByteStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_vertexByteStride_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (uint32_t) ((arg1)->vertexByteStride);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_vertexByteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_vertexByteSize_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_vertexByteSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->vertexByteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_vertexByteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_vertexByteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_vertexByteSize_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (uint64_t) ((arg1)->vertexByteSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_meshletSizes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  rdcarray< MeshletSize > *arg2 = (rdcarray< MeshletSize > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_meshletSizes_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'MeshFormat_meshletSizes_set' argument 2 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'MeshFormat_meshletSizes_set' argument 2 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->meshletSizes = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_meshletSizes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< MeshletSize > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_meshletSizes_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_meshletSizes_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (rdcarray< MeshletSize > *)& ((arg1)->meshletSizes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_MeshletSize_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_dispatchSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  rdcfixedarray< uint32_t,3 > *arg2 = (rdcfixedarray< uint32_t,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_dispatchSize_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'MeshFormat_dispatchSize_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'MeshFormat_dispatchSize_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->dispatchSize = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_dispatchSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint32_t,3 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_dispatchSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_dispatchSize_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (rdcfixedarray< uint32_t,3 > *)& ((arg1)->dispatchSize);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_taskSizes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  rdcarray< TaskGroupSize > *arg2 = (rdcarray< TaskGroupSize > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_taskSizes_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'MeshFormat_taskSizes_set' argument 2 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'MeshFormat_taskSizes_set' argument 2 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->taskSizes = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_taskSizes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< TaskGroupSize > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_taskSizes_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_taskSizes_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (rdcarray< TaskGroupSize > *)& ((arg1)->taskSizes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_TaskGroupSize_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_meshletOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_meshletOffset_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_meshletOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->meshletOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_meshletOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_meshletOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_meshletOffset_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (uint32_t) ((arg1)->meshletOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_meshletIndexOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_meshletIndexOffset_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_meshletIndexOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->meshletIndexOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_meshletIndexOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_meshletIndexOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_meshletIndexOffset_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (uint32_t) ((arg1)->meshletIndexOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_perPrimitiveOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_perPrimitiveOffset_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_perPrimitiveOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->perPrimitiveOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_perPrimitiveOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_perPrimitiveOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_perPrimitiveOffset_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (uint64_t) ((arg1)->perPrimitiveOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_perPrimitiveStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_perPrimitiveStride_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_perPrimitiveStride_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->perPrimitiveStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_perPrimitiveStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_perPrimitiveStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_perPrimitiveStride_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (uint32_t) ((arg1)->perPrimitiveStride);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_format_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  ResourceFormat *arg2 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_format_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshFormat_format_set" "', argument " "2"" of type '" "ResourceFormat *""'"); 
  }
  arg2 = reinterpret_cast< ResourceFormat * >(argp2);
  if (arg1) (arg1)->format = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_format_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceFormat *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_format_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_format_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (ResourceFormat *)& ((arg1)->format);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_meshColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  FloatVector *arg2 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_meshColor_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshFormat_meshColor_set" "', argument " "2"" of type '" "FloatVector *""'"); 
  }
  arg2 = reinterpret_cast< FloatVector * >(argp2);
  if (arg1) (arg1)->meshColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_meshColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatVector *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_meshColor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_meshColor_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (FloatVector *)& ((arg1)->meshColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloatVector, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_topology_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  Topology arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_topology_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_topology_set" "', argument " "2"" of type '" "Topology""'");
  } 
  arg2 = static_cast< Topology >(val2);
  if (arg1) (arg1)->topology = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_topology_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Topology result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_topology_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_topology_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (Topology) ((arg1)->topology);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_Topology->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_numIndices_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_numIndices_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_numIndices_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->numIndices = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_numIndices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_numIndices_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_numIndices_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (uint32_t) ((arg1)->numIndices);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_instStepRate_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_instStepRate_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_instStepRate_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->instStepRate = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_instStepRate_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_instStepRate_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_instStepRate_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (uint32_t) ((arg1)->instStepRate);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_restartIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_restartIndex_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_restartIndex_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->restartIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_restartIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_restartIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_restartIndex_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (uint32_t) ((arg1)->restartIndex);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_nearPlane_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_nearPlane_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_nearPlane_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->nearPlane = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_nearPlane_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_nearPlane_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_nearPlane_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (float) ((arg1)->nearPlane);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_farPlane_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_farPlane_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_farPlane_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->farPlane = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_farPlane_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_farPlane_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_farPlane_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (float) ((arg1)->farPlane);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_unproject_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_unproject_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_unproject_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->unproject = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_unproject_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_unproject_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_unproject_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (bool) ((arg1)->unproject);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_flipY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_flipY_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_flipY_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->flipY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_flipY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_flipY_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_flipY_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (bool) ((arg1)->flipY);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_instanced_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_instanced_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_instanced_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->instanced = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_instanced_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_instanced_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_instanced_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (bool) ((arg1)->instanced);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_showAlpha_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_showAlpha_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_showAlpha_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->showAlpha = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_showAlpha_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_showAlpha_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_showAlpha_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (bool) ((arg1)->showAlpha);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_allowRestart_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_allowRestart_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshFormat_allowRestart_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->allowRestart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_allowRestart_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_allowRestart_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_allowRestart_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result = (bool) ((arg1)->allowRestart);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_status_set" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'MeshFormat_status_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshFormat_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshFormat_status_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshFormat_status_get" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  result =  ((arg1)->status);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MeshFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshFormat *arg1 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_MeshFormat",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshFormat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MeshFormat" "', argument " "1"" of type '" "MeshFormat *""'"); 
  }
  arg1 = reinterpret_cast< MeshFormat * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_MeshFormat) /* defines _wrap_delete_MeshFormat_destructor_closure */

SWIGINTERN int _wrap_new_MeshDisplay__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  MeshDisplay *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (MeshDisplay *)new MeshDisplay();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MeshDisplay, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_MeshDisplay__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  MeshDisplay *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_MeshDisplay,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MeshDisplay" "', argument " "1"" of type '" "MeshDisplay const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MeshDisplay" "', argument " "1"" of type '" "MeshDisplay const &""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (MeshDisplay *)new MeshDisplay((MeshDisplay const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MeshDisplay, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_MeshDisplay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_MeshDisplay",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MeshDisplay__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_MeshDisplay__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MeshDisplay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MeshDisplay::MeshDisplay()\n"
    "    MeshDisplay::MeshDisplay(MeshDisplay const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  MeshDataStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_type_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_type_set" "', argument " "2"" of type '" "MeshDataStage""'");
  } 
  arg2 = static_cast< MeshDataStage >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MeshDataStage result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_type_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (MeshDataStage) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_MeshDataStage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_cam_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  ICamera *arg2 = (ICamera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_cam_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ICamera, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshDisplay_cam_set" "', argument " "2"" of type '" "ICamera *""'"); 
  }
  arg2 = reinterpret_cast< ICamera * >(argp2);
  if (arg1) (arg1)->cam = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_cam_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ICamera *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_cam_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_cam_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (ICamera *) ((arg1)->cam);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ICamera, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_axisMapping_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  AxisMapping *arg2 = (AxisMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_axisMapping_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_AxisMapping, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshDisplay_axisMapping_set" "', argument " "2"" of type '" "AxisMapping *""'"); 
  }
  arg2 = reinterpret_cast< AxisMapping * >(argp2);
  if (arg1) (arg1)->axisMapping = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_axisMapping_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AxisMapping *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_axisMapping_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_axisMapping_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (AxisMapping *)& ((arg1)->axisMapping);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AxisMapping, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_ortho_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_ortho_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_ortho_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->ortho = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_ortho_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_ortho_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_ortho_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (bool) ((arg1)->ortho);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_fov_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_fov_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_fov_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->fov = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_fov_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_fov_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_fov_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (float) ((arg1)->fov);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_aspect_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_aspect_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_aspect_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->aspect = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_aspect_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_aspect_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_aspect_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (float) ((arg1)->aspect);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_showPrevInstances_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_showPrevInstances_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_showPrevInstances_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->showPrevInstances = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_showPrevInstances_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_showPrevInstances_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_showPrevInstances_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (bool) ((arg1)->showPrevInstances);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_showAllInstances_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_showAllInstances_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_showAllInstances_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->showAllInstances = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_showAllInstances_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_showAllInstances_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_showAllInstances_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (bool) ((arg1)->showAllInstances);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_showWholePass_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_showWholePass_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_showWholePass_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->showWholePass = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_showWholePass_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_showWholePass_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_showWholePass_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (bool) ((arg1)->showWholePass);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_curInstance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_curInstance_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_curInstance_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->curInstance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_curInstance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_curInstance_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_curInstance_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (uint32_t) ((arg1)->curInstance);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_curView_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_curView_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_curView_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->curView = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_curView_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_curView_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_curView_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (uint32_t) ((arg1)->curView);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_highlightVert_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_highlightVert_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_highlightVert_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->highlightVert = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_highlightVert_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_highlightVert_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_highlightVert_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (uint32_t) ((arg1)->highlightVert);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_position_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  MeshFormat *arg2 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_position_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshDisplay_position_set" "', argument " "2"" of type '" "MeshFormat *""'"); 
  }
  arg2 = reinterpret_cast< MeshFormat * >(argp2);
  if (arg1) (arg1)->position = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_position_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MeshFormat *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_position_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_position_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (MeshFormat *)& ((arg1)->position);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  MeshFormat *arg2 = (MeshFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_second_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshDisplay_second_set" "', argument " "2"" of type '" "MeshFormat *""'"); 
  }
  arg2 = reinterpret_cast< MeshFormat * >(argp2);
  if (arg1) (arg1)->second = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MeshFormat *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_second_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_second_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (MeshFormat *)& ((arg1)->second);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MeshFormat, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_minBounds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  FloatVector *arg2 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_minBounds_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshDisplay_minBounds_set" "', argument " "2"" of type '" "FloatVector *""'"); 
  }
  arg2 = reinterpret_cast< FloatVector * >(argp2);
  if (arg1) (arg1)->minBounds = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_minBounds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatVector *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_minBounds_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_minBounds_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (FloatVector *)& ((arg1)->minBounds);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloatVector, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_maxBounds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  FloatVector *arg2 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_maxBounds_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshDisplay_maxBounds_set" "', argument " "2"" of type '" "FloatVector *""'"); 
  }
  arg2 = reinterpret_cast< FloatVector * >(argp2);
  if (arg1) (arg1)->maxBounds = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_maxBounds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatVector *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_maxBounds_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_maxBounds_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (FloatVector *)& ((arg1)->maxBounds);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloatVector, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_showBBox_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_showBBox_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_showBBox_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->showBBox = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_showBBox_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_showBBox_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_showBBox_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (bool) ((arg1)->showBBox);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_visualisationMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  Visualisation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_visualisationMode_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_visualisationMode_set" "', argument " "2"" of type '" "Visualisation""'");
  } 
  arg2 = static_cast< Visualisation >(val2);
  if (arg1) (arg1)->visualisationMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_visualisationMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Visualisation result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_visualisationMode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_visualisationMode_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (Visualisation) ((arg1)->visualisationMode);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_Visualisation->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_wireframeDraw_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_wireframeDraw_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_wireframeDraw_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->wireframeDraw = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_wireframeDraw_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_wireframeDraw_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_wireframeDraw_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (bool) ((arg1)->wireframeDraw);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_vtxExploderSliderSNorm_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_vtxExploderSliderSNorm_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_vtxExploderSliderSNorm_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->vtxExploderSliderSNorm = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_vtxExploderSliderSNorm_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_vtxExploderSliderSNorm_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_vtxExploderSliderSNorm_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (float) ((arg1)->vtxExploderSliderSNorm);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_exploderScale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_exploderScale_set" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MeshDisplay_exploderScale_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->exploderScale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MeshDisplay_exploderScale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"MeshDisplay_exploderScale_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshDisplay_exploderScale_get" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  result = (float) ((arg1)->exploderScale);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MeshDisplay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDisplay *arg1 = (MeshDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_MeshDisplay",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDisplay, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MeshDisplay" "', argument " "1"" of type '" "MeshDisplay *""'"); 
  }
  arg1 = reinterpret_cast< MeshDisplay * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_MeshDisplay) /* defines _wrap_delete_MeshDisplay_destructor_closure */

SWIGINTERN int _wrap_new_TextureDisplay__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TextureDisplay *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (TextureDisplay *)new TextureDisplay();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureDisplay, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureDisplay__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TextureDisplay *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TextureDisplay,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TextureDisplay" "', argument " "1"" of type '" "TextureDisplay const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TextureDisplay" "', argument " "1"" of type '" "TextureDisplay const &""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (TextureDisplay *)new TextureDisplay((TextureDisplay const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureDisplay, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureDisplay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_TextureDisplay",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TextureDisplay__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_TextureDisplay__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TextureDisplay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TextureDisplay::TextureDisplay()\n"
    "    TextureDisplay::TextureDisplay(TextureDisplay const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_resourceId_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureDisplay_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_resourceId_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_typeCast_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  CompType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_typeCast_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_typeCast_set" "', argument " "2"" of type '" "CompType""'");
  } 
  arg2 = static_cast< CompType >(val2);
  if (arg1) (arg1)->typeCast = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_typeCast_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompType result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_typeCast_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_typeCast_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (CompType) ((arg1)->typeCast);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CompType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_rangeMin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_rangeMin_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_rangeMin_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->rangeMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_rangeMin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_rangeMin_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_rangeMin_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (float) ((arg1)->rangeMin);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_rangeMax_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_rangeMax_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_rangeMax_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->rangeMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_rangeMax_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_rangeMax_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_rangeMax_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (float) ((arg1)->rangeMax);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_scale_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_scale_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_scale_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_scale_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (float) ((arg1)->scale);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_red_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_red_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_red_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->red = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_red_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_red_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_red_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (bool) ((arg1)->red);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_green_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_green_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_green_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->green = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_green_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_green_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_green_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (bool) ((arg1)->green);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_blue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_blue_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_blue_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->blue = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_blue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_blue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_blue_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (bool) ((arg1)->blue);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_alpha_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_alpha_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_alpha_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->alpha = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_alpha_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_alpha_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_alpha_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (bool) ((arg1)->alpha);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_flipY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_flipY_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_flipY_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->flipY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_flipY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_flipY_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_flipY_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (bool) ((arg1)->flipY);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_hdrMultiplier_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_hdrMultiplier_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_hdrMultiplier_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->hdrMultiplier = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_hdrMultiplier_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_hdrMultiplier_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_hdrMultiplier_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (float) ((arg1)->hdrMultiplier);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_decodeYUV_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_decodeYUV_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_decodeYUV_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->decodeYUV = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_decodeYUV_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_decodeYUV_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_decodeYUV_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (bool) ((arg1)->decodeYUV);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_linearDisplayAsGamma_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_linearDisplayAsGamma_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_linearDisplayAsGamma_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->linearDisplayAsGamma = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_linearDisplayAsGamma_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_linearDisplayAsGamma_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_linearDisplayAsGamma_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (bool) ((arg1)->linearDisplayAsGamma);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_customShaderId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_customShaderId_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureDisplay_customShaderId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->customShaderId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_customShaderId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_customShaderId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_customShaderId_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (ResourceId *)& ((arg1)->customShaderId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_subresource_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  Subresource *arg2 = (Subresource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_subresource_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_Subresource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureDisplay_subresource_set" "', argument " "2"" of type '" "Subresource *""'"); 
  }
  arg2 = reinterpret_cast< Subresource * >(argp2);
  if (arg1) (arg1)->subresource = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_subresource_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Subresource *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_subresource_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_subresource_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (Subresource *)& ((arg1)->subresource);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Subresource, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_rawOutput_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_rawOutput_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_rawOutput_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->rawOutput = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_rawOutput_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_rawOutput_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_rawOutput_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (bool) ((arg1)->rawOutput);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_xOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_xOffset_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_xOffset_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->xOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_xOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_xOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_xOffset_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (float) ((arg1)->xOffset);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_yOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_yOffset_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_yOffset_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->yOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_yOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_yOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_yOffset_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (float) ((arg1)->yOffset);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_backgroundColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  FloatVector *arg2 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_backgroundColor_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureDisplay_backgroundColor_set" "', argument " "2"" of type '" "FloatVector *""'"); 
  }
  arg2 = reinterpret_cast< FloatVector * >(argp2);
  if (arg1) (arg1)->backgroundColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_backgroundColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatVector *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_backgroundColor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_backgroundColor_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (FloatVector *)& ((arg1)->backgroundColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloatVector, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_overlay_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  DebugOverlay arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_overlay_set" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDisplay_overlay_set" "', argument " "2"" of type '" "DebugOverlay""'");
  } 
  arg2 = static_cast< DebugOverlay >(val2);
  if (arg1) (arg1)->overlay = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDisplay_overlay_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DebugOverlay result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDisplay_overlay_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDisplay_overlay_get" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  result = (DebugOverlay) ((arg1)->overlay);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_DebugOverlay->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TextureDisplay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDisplay *arg1 = (TextureDisplay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TextureDisplay",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDisplay, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TextureDisplay" "', argument " "1"" of type '" "TextureDisplay *""'"); 
  }
  arg1 = reinterpret_cast< TextureDisplay * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TextureDisplay) /* defines _wrap_delete_TextureDisplay_destructor_closure */

SWIGINTERN int _wrap_new_TextureComponentMapping__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TextureComponentMapping *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (TextureComponentMapping *)new TextureComponentMapping();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureComponentMapping, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureComponentMapping__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TextureComponentMapping *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TextureComponentMapping *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TextureComponentMapping,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TextureComponentMapping" "', argument " "1"" of type '" "TextureComponentMapping const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TextureComponentMapping" "', argument " "1"" of type '" "TextureComponentMapping const &""'"); 
  }
  arg1 = reinterpret_cast< TextureComponentMapping * >(argp1);
  result = (TextureComponentMapping *)new TextureComponentMapping((TextureComponentMapping const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureComponentMapping, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureComponentMapping(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_TextureComponentMapping",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TextureComponentMapping__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_TextureComponentMapping__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TextureComponentMapping'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TextureComponentMapping::TextureComponentMapping()\n"
    "    TextureComponentMapping::TextureComponentMapping(TextureComponentMapping const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_TextureComponentMapping_blackPoint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureComponentMapping *arg1 = (TextureComponentMapping *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureComponentMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureComponentMapping_blackPoint_set" "', argument " "1"" of type '" "TextureComponentMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureComponentMapping * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureComponentMapping_blackPoint_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->blackPoint = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureComponentMapping_blackPoint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureComponentMapping *arg1 = (TextureComponentMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureComponentMapping_blackPoint_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureComponentMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureComponentMapping_blackPoint_get" "', argument " "1"" of type '" "TextureComponentMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureComponentMapping * >(argp1);
  result = (float) ((arg1)->blackPoint);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureComponentMapping_whitePoint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureComponentMapping *arg1 = (TextureComponentMapping *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureComponentMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureComponentMapping_whitePoint_set" "', argument " "1"" of type '" "TextureComponentMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureComponentMapping * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureComponentMapping_whitePoint_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->whitePoint = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureComponentMapping_whitePoint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureComponentMapping *arg1 = (TextureComponentMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureComponentMapping_whitePoint_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureComponentMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureComponentMapping_whitePoint_get" "', argument " "1"" of type '" "TextureComponentMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureComponentMapping * >(argp1);
  result = (float) ((arg1)->whitePoint);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TextureComponentMapping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureComponentMapping *arg1 = (TextureComponentMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TextureComponentMapping",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureComponentMapping, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TextureComponentMapping" "', argument " "1"" of type '" "TextureComponentMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureComponentMapping * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TextureComponentMapping) /* defines _wrap_delete_TextureComponentMapping_destructor_closure */

SWIGINTERN int _wrap_new_TextureSampleMapping__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TextureSampleMapping *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (TextureSampleMapping *)new TextureSampleMapping();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureSampleMapping, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureSampleMapping__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TextureSampleMapping *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TextureSampleMapping *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TextureSampleMapping,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TextureSampleMapping" "', argument " "1"" of type '" "TextureSampleMapping const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TextureSampleMapping" "', argument " "1"" of type '" "TextureSampleMapping const &""'"); 
  }
  arg1 = reinterpret_cast< TextureSampleMapping * >(argp1);
  result = (TextureSampleMapping *)new TextureSampleMapping((TextureSampleMapping const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureSampleMapping, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureSampleMapping(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_TextureSampleMapping",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TextureSampleMapping__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_TextureSampleMapping__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TextureSampleMapping'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TextureSampleMapping::TextureSampleMapping()\n"
    "    TextureSampleMapping::TextureSampleMapping(TextureSampleMapping const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_TextureSampleMapping_mapToArray_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSampleMapping *arg1 = (TextureSampleMapping *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSampleMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSampleMapping_mapToArray_set" "', argument " "1"" of type '" "TextureSampleMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSampleMapping * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSampleMapping_mapToArray_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->mapToArray = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSampleMapping_mapToArray_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSampleMapping *arg1 = (TextureSampleMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSampleMapping_mapToArray_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSampleMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSampleMapping_mapToArray_get" "', argument " "1"" of type '" "TextureSampleMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSampleMapping * >(argp1);
  result = (bool) ((arg1)->mapToArray);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSampleMapping_sampleIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSampleMapping *arg1 = (TextureSampleMapping *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSampleMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSampleMapping_sampleIndex_set" "', argument " "1"" of type '" "TextureSampleMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSampleMapping * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSampleMapping_sampleIndex_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sampleIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSampleMapping_sampleIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSampleMapping *arg1 = (TextureSampleMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSampleMapping_sampleIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSampleMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSampleMapping_sampleIndex_get" "', argument " "1"" of type '" "TextureSampleMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSampleMapping * >(argp1);
  result = (uint32_t) ((arg1)->sampleIndex);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TextureSampleMapping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSampleMapping *arg1 = (TextureSampleMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TextureSampleMapping",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSampleMapping, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TextureSampleMapping" "', argument " "1"" of type '" "TextureSampleMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSampleMapping * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TextureSampleMapping) /* defines _wrap_delete_TextureSampleMapping_destructor_closure */

SWIGINTERN int _wrap_new_TextureSliceMapping__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TextureSliceMapping *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (TextureSliceMapping *)new TextureSliceMapping();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureSliceMapping, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureSliceMapping__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TextureSliceMapping *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TextureSliceMapping *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TextureSliceMapping,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TextureSliceMapping" "', argument " "1"" of type '" "TextureSliceMapping const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TextureSliceMapping" "', argument " "1"" of type '" "TextureSliceMapping const &""'"); 
  }
  arg1 = reinterpret_cast< TextureSliceMapping * >(argp1);
  result = (TextureSliceMapping *)new TextureSliceMapping((TextureSliceMapping const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureSliceMapping, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureSliceMapping(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_TextureSliceMapping",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TextureSliceMapping__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_TextureSliceMapping__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TextureSliceMapping'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TextureSliceMapping::TextureSliceMapping()\n"
    "    TextureSliceMapping::TextureSliceMapping(TextureSliceMapping const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_TextureSliceMapping_sliceIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSliceMapping *arg1 = (TextureSliceMapping *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSliceMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSliceMapping_sliceIndex_set" "', argument " "1"" of type '" "TextureSliceMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSliceMapping * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSliceMapping_sliceIndex_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->sliceIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSliceMapping_sliceIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSliceMapping *arg1 = (TextureSliceMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSliceMapping_sliceIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSliceMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSliceMapping_sliceIndex_get" "', argument " "1"" of type '" "TextureSliceMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSliceMapping * >(argp1);
  result = (int32_t) ((arg1)->sliceIndex);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSliceMapping_slicesAsGrid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSliceMapping *arg1 = (TextureSliceMapping *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSliceMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSliceMapping_slicesAsGrid_set" "', argument " "1"" of type '" "TextureSliceMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSliceMapping * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSliceMapping_slicesAsGrid_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->slicesAsGrid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSliceMapping_slicesAsGrid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSliceMapping *arg1 = (TextureSliceMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSliceMapping_slicesAsGrid_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSliceMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSliceMapping_slicesAsGrid_get" "', argument " "1"" of type '" "TextureSliceMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSliceMapping * >(argp1);
  result = (bool) ((arg1)->slicesAsGrid);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSliceMapping_sliceGridWidth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSliceMapping *arg1 = (TextureSliceMapping *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSliceMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSliceMapping_sliceGridWidth_set" "', argument " "1"" of type '" "TextureSliceMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSliceMapping * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSliceMapping_sliceGridWidth_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->sliceGridWidth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSliceMapping_sliceGridWidth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSliceMapping *arg1 = (TextureSliceMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSliceMapping_sliceGridWidth_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSliceMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSliceMapping_sliceGridWidth_get" "', argument " "1"" of type '" "TextureSliceMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSliceMapping * >(argp1);
  result = (int32_t) ((arg1)->sliceGridWidth);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSliceMapping_cubeCruciform_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSliceMapping *arg1 = (TextureSliceMapping *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSliceMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSliceMapping_cubeCruciform_set" "', argument " "1"" of type '" "TextureSliceMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSliceMapping * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSliceMapping_cubeCruciform_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->cubeCruciform = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSliceMapping_cubeCruciform_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSliceMapping *arg1 = (TextureSliceMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSliceMapping_cubeCruciform_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSliceMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSliceMapping_cubeCruciform_get" "', argument " "1"" of type '" "TextureSliceMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSliceMapping * >(argp1);
  result = (bool) ((arg1)->cubeCruciform);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TextureSliceMapping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSliceMapping *arg1 = (TextureSliceMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TextureSliceMapping",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSliceMapping, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TextureSliceMapping" "', argument " "1"" of type '" "TextureSliceMapping *""'"); 
  }
  arg1 = reinterpret_cast< TextureSliceMapping * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TextureSliceMapping) /* defines _wrap_delete_TextureSliceMapping_destructor_closure */

SWIGINTERN int _wrap_new_TextureSave__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TextureSave *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (TextureSave *)new TextureSave();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureSave, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureSave__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TextureSave *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TextureSave,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TextureSave" "', argument " "1"" of type '" "TextureSave const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TextureSave" "', argument " "1"" of type '" "TextureSave const &""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  result = (TextureSave *)new TextureSave((TextureSave const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureSave, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureSave(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_TextureSave",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TextureSave__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_TextureSave__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TextureSave'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TextureSave::TextureSave()\n"
    "    TextureSave::TextureSave(TextureSave const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_TextureSave_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_resourceId_set" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureSave_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSave_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_resourceId_get" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_typeCast_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  CompType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_typeCast_set" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSave_typeCast_set" "', argument " "2"" of type '" "CompType""'");
  } 
  arg2 = static_cast< CompType >(val2);
  if (arg1) (arg1)->typeCast = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_typeCast_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompType result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSave_typeCast_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_typeCast_get" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  result = (CompType) ((arg1)->typeCast);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CompType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_destType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  FileType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_destType_set" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSave_destType_set" "', argument " "2"" of type '" "FileType""'");
  } 
  arg2 = static_cast< FileType >(val2);
  if (arg1) (arg1)->destType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_destType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FileType result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSave_destType_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_destType_get" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  result = (FileType) ((arg1)->destType);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_FileType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_mip_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_mip_set" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSave_mip_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->mip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_mip_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSave_mip_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_mip_get" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  result = (int32_t) ((arg1)->mip);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_comp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  TextureComponentMapping *arg2 = (TextureComponentMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_comp_set" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_TextureComponentMapping, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureSave_comp_set" "', argument " "2"" of type '" "TextureComponentMapping *""'"); 
  }
  arg2 = reinterpret_cast< TextureComponentMapping * >(argp2);
  if (arg1) (arg1)->comp = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_comp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureComponentMapping *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSave_comp_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_comp_get" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  result = (TextureComponentMapping *)& ((arg1)->comp);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureComponentMapping, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_sample_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  TextureSampleMapping *arg2 = (TextureSampleMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_sample_set" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_TextureSampleMapping, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureSave_sample_set" "', argument " "2"" of type '" "TextureSampleMapping *""'"); 
  }
  arg2 = reinterpret_cast< TextureSampleMapping * >(argp2);
  if (arg1) (arg1)->sample = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_sample_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureSampleMapping *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSave_sample_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_sample_get" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  result = (TextureSampleMapping *)& ((arg1)->sample);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureSampleMapping, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_slice_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  TextureSliceMapping *arg2 = (TextureSliceMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_slice_set" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_TextureSliceMapping, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureSave_slice_set" "', argument " "2"" of type '" "TextureSliceMapping *""'"); 
  }
  arg2 = reinterpret_cast< TextureSliceMapping * >(argp2);
  if (arg1) (arg1)->slice = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_slice_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureSliceMapping *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSave_slice_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_slice_get" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  result = (TextureSliceMapping *)& ((arg1)->slice);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureSliceMapping, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_channelExtract_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_channelExtract_set" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSave_channelExtract_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->channelExtract = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_channelExtract_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSave_channelExtract_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_channelExtract_get" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  result = (int) ((arg1)->channelExtract);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_alpha_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  AlphaMapping arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_alpha_set" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSave_alpha_set" "', argument " "2"" of type '" "AlphaMapping""'");
  } 
  arg2 = static_cast< AlphaMapping >(val2);
  if (arg1) (arg1)->alpha = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_alpha_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AlphaMapping result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSave_alpha_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_alpha_get" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  result = (AlphaMapping) ((arg1)->alpha);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_AlphaMapping->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_alphaCol_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  FloatVector *arg2 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_alphaCol_set" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureSave_alphaCol_set" "', argument " "2"" of type '" "FloatVector *""'"); 
  }
  arg2 = reinterpret_cast< FloatVector * >(argp2);
  if (arg1) (arg1)->alphaCol = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_alphaCol_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatVector *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSave_alphaCol_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_alphaCol_get" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  result = (FloatVector *)& ((arg1)->alphaCol);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloatVector, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_jpegQuality_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_jpegQuality_set" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSave_jpegQuality_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->jpegQuality = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSave_jpegQuality_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSave_jpegQuality_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSave_jpegQuality_get" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  result = (int) ((arg1)->jpegQuality);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TextureSave(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSave *arg1 = (TextureSave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TextureSave",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSave, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TextureSave" "', argument " "1"" of type '" "TextureSave *""'"); 
  }
  arg1 = reinterpret_cast< TextureSave * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TextureSave) /* defines _wrap_delete_TextureSave_destructor_closure */

SWIGINTERN int _wrap_new_DescriptorRange__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  DescriptorRange *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (DescriptorRange *)new DescriptorRange();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DescriptorRange, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DescriptorRange__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DescriptorRange *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DescriptorRange *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DescriptorRange,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DescriptorRange" "', argument " "1"" of type '" "DescriptorRange const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DescriptorRange" "', argument " "1"" of type '" "DescriptorRange const &""'"); 
  }
  arg1 = reinterpret_cast< DescriptorRange * >(argp1);
  result = (DescriptorRange *)new DescriptorRange((DescriptorRange const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DescriptorRange, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DescriptorRange__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DescriptorRange *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DescriptorAccess,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DescriptorRange" "', argument " "1"" of type '" "DescriptorAccess const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DescriptorRange" "', argument " "1"" of type '" "DescriptorAccess const &""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  result = (DescriptorRange *)new DescriptorRange((DescriptorAccess const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DescriptorRange, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DescriptorRange(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DescriptorRange",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DescriptorRange__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_DescriptorRange, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_DescriptorRange__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    return _wrap_new_DescriptorRange__SWIG_2(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DescriptorRange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DescriptorRange::DescriptorRange()\n"
    "    DescriptorRange::DescriptorRange(DescriptorRange const &)\n"
    "    DescriptorRange::DescriptorRange(DescriptorAccess const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_DescriptorRange_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorRange *arg1 = (DescriptorRange *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorRange_offset_set" "', argument " "1"" of type '" "DescriptorRange *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorRange * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorRange_offset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorRange_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorRange *arg1 = (DescriptorRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorRange_offset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorRange_offset_get" "', argument " "1"" of type '" "DescriptorRange *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorRange * >(argp1);
  result = (uint32_t) ((arg1)->offset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorRange_descriptorSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorRange *arg1 = (DescriptorRange *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorRange_descriptorSize_set" "', argument " "1"" of type '" "DescriptorRange *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorRange * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorRange_descriptorSize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->descriptorSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorRange_descriptorSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorRange *arg1 = (DescriptorRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorRange_descriptorSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorRange_descriptorSize_get" "', argument " "1"" of type '" "DescriptorRange *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorRange * >(argp1);
  result = (uint32_t) ((arg1)->descriptorSize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorRange_count_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorRange *arg1 = (DescriptorRange *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorRange_count_set" "', argument " "1"" of type '" "DescriptorRange *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorRange * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorRange_count_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->count = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorRange_count_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorRange *arg1 = (DescriptorRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorRange_count_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorRange_count_get" "', argument " "1"" of type '" "DescriptorRange *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorRange * >(argp1);
  result = (uint32_t) ((arg1)->count);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorRange_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorRange *arg1 = (DescriptorRange *) 0 ;
  DescriptorType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorRange_type_set" "', argument " "1"" of type '" "DescriptorRange *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorRange * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorRange_type_set" "', argument " "2"" of type '" "DescriptorType""'");
  } 
  arg2 = static_cast< DescriptorType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorRange_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorRange *arg1 = (DescriptorRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DescriptorType result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorRange_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorRange_type_get" "', argument " "1"" of type '" "DescriptorRange *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorRange * >(argp1);
  result = (DescriptorType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_DescriptorType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorRange___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorRange *arg1 = (DescriptorRange *) 0 ;
  DescriptorRange *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorRange___eq__" "', argument " "1"" of type '" "DescriptorRange const *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorRange * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_DescriptorRange,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DescriptorRange___eq__" "', argument " "2"" of type '" "DescriptorRange const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DescriptorRange___eq__" "', argument " "2"" of type '" "DescriptorRange const &""'"); 
  }
  arg2 = reinterpret_cast< DescriptorRange * >(argp2);
  result = (bool)((DescriptorRange const *)arg1)->operator ==((DescriptorRange const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorRange___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorRange *arg1 = (DescriptorRange *) 0 ;
  DescriptorRange *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorRange___lt__" "', argument " "1"" of type '" "DescriptorRange const *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorRange * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_DescriptorRange,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DescriptorRange___lt__" "', argument " "2"" of type '" "DescriptorRange const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DescriptorRange___lt__" "', argument " "2"" of type '" "DescriptorRange const &""'"); 
  }
  arg2 = reinterpret_cast< DescriptorRange * >(argp2);
  result = (bool)((DescriptorRange const *)arg1)->operator <((DescriptorRange const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DescriptorRange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorRange *arg1 = (DescriptorRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DescriptorRange",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorRange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DescriptorRange" "', argument " "1"" of type '" "DescriptorRange *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorRange * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DescriptorRange) /* defines _wrap_delete_DescriptorRange_destructor_closure */

SWIGINTERN int _wrap_new_NewCaptureData__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  NewCaptureData *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (NewCaptureData *)new NewCaptureData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NewCaptureData, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_NewCaptureData__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  NewCaptureData *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_NewCaptureData,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewCaptureData" "', argument " "1"" of type '" "NewCaptureData const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NewCaptureData" "', argument " "1"" of type '" "NewCaptureData const &""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  result = (NewCaptureData *)new NewCaptureData((NewCaptureData const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NewCaptureData, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_NewCaptureData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_NewCaptureData",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_NewCaptureData__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_NewCaptureData__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NewCaptureData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    NewCaptureData::NewCaptureData()\n"
    "    NewCaptureData::NewCaptureData(NewCaptureData const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_captureId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_captureId_set" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewCaptureData_captureId_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->captureId = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_captureId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"NewCaptureData_captureId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_captureId_get" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  result = (uint32_t) ((arg1)->captureId);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_frameNumber_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_frameNumber_set" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewCaptureData_frameNumber_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->frameNumber = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_frameNumber_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"NewCaptureData_frameNumber_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_frameNumber_get" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  result = (uint32_t) ((arg1)->frameNumber);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_timestamp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_timestamp_set" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewCaptureData_timestamp_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->timestamp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_timestamp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"NewCaptureData_timestamp_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_timestamp_get" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  result = (uint64_t) ((arg1)->timestamp);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_byteSize_set" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewCaptureData_byteSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"NewCaptureData_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_byteSize_get" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  result = (uint64_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_thumbnail_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  bytebuf *arg2 = (bytebuf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bytebuf temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_thumbnail_set" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'NewCaptureData_thumbnail_set' argument 2 of type 'bytebuf'"); 
    }
  }
  if (arg1) (arg1)->thumbnail = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_thumbnail_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bytebuf *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"NewCaptureData_thumbnail_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_thumbnail_get" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  result = (bytebuf *)& ((arg1)->thumbnail);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_thumbWidth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_thumbWidth_set" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewCaptureData_thumbWidth_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->thumbWidth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_thumbWidth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"NewCaptureData_thumbWidth_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_thumbWidth_get" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  result = (int32_t) ((arg1)->thumbWidth);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_thumbHeight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_thumbHeight_set" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewCaptureData_thumbHeight_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->thumbHeight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_thumbHeight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"NewCaptureData_thumbHeight_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_thumbHeight_get" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  result = (int32_t) ((arg1)->thumbHeight);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_path_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_path_set" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'NewCaptureData_path_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->path = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_path_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"NewCaptureData_path_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_path_get" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  result =  ((arg1)->path);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_title_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_title_set" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'NewCaptureData_title_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->title = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_title_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"NewCaptureData_title_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_title_get" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  result =  ((arg1)->title);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_api_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_api_set" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'NewCaptureData_api_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->api = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_api_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"NewCaptureData_api_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_api_get" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  result =  ((arg1)->api);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_local_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_local_set" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewCaptureData_local_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->local = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewCaptureData_local_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"NewCaptureData_local_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewCaptureData_local_get" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  result = (bool) ((arg1)->local);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NewCaptureData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewCaptureData *arg1 = (NewCaptureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_NewCaptureData",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewCaptureData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewCaptureData" "', argument " "1"" of type '" "NewCaptureData *""'"); 
  }
  arg1 = reinterpret_cast< NewCaptureData * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_NewCaptureData) /* defines _wrap_delete_NewCaptureData_destructor_closure */

SWIGINTERN int _wrap_new_APIUseData__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  APIUseData *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (APIUseData *)new APIUseData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_APIUseData, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_APIUseData__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  APIUseData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  APIUseData *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_APIUseData,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_APIUseData" "', argument " "1"" of type '" "APIUseData const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_APIUseData" "', argument " "1"" of type '" "APIUseData const &""'"); 
  }
  arg1 = reinterpret_cast< APIUseData * >(argp1);
  result = (APIUseData *)new APIUseData((APIUseData const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_APIUseData, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_APIUseData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_APIUseData",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_APIUseData__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_APIUseData__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_APIUseData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    APIUseData::APIUseData()\n"
    "    APIUseData::APIUseData(APIUseData const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_APIUseData_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIUseData *arg1 = (APIUseData *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIUseData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIUseData_name_set" "', argument " "1"" of type '" "APIUseData *""'"); 
  }
  arg1 = reinterpret_cast< APIUseData * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'APIUseData_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIUseData_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIUseData *arg1 = (APIUseData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIUseData_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIUseData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIUseData_name_get" "', argument " "1"" of type '" "APIUseData *""'"); 
  }
  arg1 = reinterpret_cast< APIUseData * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIUseData_presenting_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIUseData *arg1 = (APIUseData *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIUseData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIUseData_presenting_set" "', argument " "1"" of type '" "APIUseData *""'"); 
  }
  arg1 = reinterpret_cast< APIUseData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "APIUseData_presenting_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->presenting = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIUseData_presenting_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIUseData *arg1 = (APIUseData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIUseData_presenting_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIUseData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIUseData_presenting_get" "', argument " "1"" of type '" "APIUseData *""'"); 
  }
  arg1 = reinterpret_cast< APIUseData * >(argp1);
  result = (bool) ((arg1)->presenting);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIUseData_supported_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIUseData *arg1 = (APIUseData *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIUseData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIUseData_supported_set" "', argument " "1"" of type '" "APIUseData *""'"); 
  }
  arg1 = reinterpret_cast< APIUseData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "APIUseData_supported_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->supported = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIUseData_supported_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIUseData *arg1 = (APIUseData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIUseData_supported_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIUseData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIUseData_supported_get" "', argument " "1"" of type '" "APIUseData *""'"); 
  }
  arg1 = reinterpret_cast< APIUseData * >(argp1);
  result = (bool) ((arg1)->supported);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIUseData_supportMessage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIUseData *arg1 = (APIUseData *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIUseData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIUseData_supportMessage_set" "', argument " "1"" of type '" "APIUseData *""'"); 
  }
  arg1 = reinterpret_cast< APIUseData * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'APIUseData_supportMessage_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->supportMessage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIUseData_supportMessage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIUseData *arg1 = (APIUseData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIUseData_supportMessage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIUseData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIUseData_supportMessage_get" "', argument " "1"" of type '" "APIUseData *""'"); 
  }
  arg1 = reinterpret_cast< APIUseData * >(argp1);
  result =  ((arg1)->supportMessage);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_APIUseData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIUseData *arg1 = (APIUseData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_APIUseData",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIUseData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_APIUseData" "', argument " "1"" of type '" "APIUseData *""'"); 
  }
  arg1 = reinterpret_cast< APIUseData * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_APIUseData) /* defines _wrap_delete_APIUseData_destructor_closure */

SWIGINTERN int _wrap_new_BusyData__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  BusyData *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (BusyData *)new BusyData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BusyData, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_BusyData__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BusyData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  BusyData *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_BusyData,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyData" "', argument " "1"" of type '" "BusyData const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BusyData" "', argument " "1"" of type '" "BusyData const &""'"); 
  }
  arg1 = reinterpret_cast< BusyData * >(argp1);
  result = (BusyData *)new BusyData((BusyData const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BusyData, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_BusyData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_BusyData",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_BusyData__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_BusyData__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BusyData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BusyData::BusyData()\n"
    "    BusyData::BusyData(BusyData const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_BusyData_clientName_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BusyData *arg1 = (BusyData *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BusyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BusyData_clientName_set" "', argument " "1"" of type '" "BusyData *""'"); 
  }
  arg1 = reinterpret_cast< BusyData * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'BusyData_clientName_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->clientName = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BusyData_clientName_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BusyData *arg1 = (BusyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"BusyData_clientName_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BusyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BusyData_clientName_get" "', argument " "1"" of type '" "BusyData *""'"); 
  }
  arg1 = reinterpret_cast< BusyData * >(argp1);
  result =  ((arg1)->clientName);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BusyData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BusyData *arg1 = (BusyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_BusyData",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BusyData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyData" "', argument " "1"" of type '" "BusyData *""'"); 
  }
  arg1 = reinterpret_cast< BusyData * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_BusyData) /* defines _wrap_delete_BusyData_destructor_closure */

SWIGINTERN int _wrap_new_NewChildData__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  NewChildData *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (NewChildData *)new NewChildData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NewChildData, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_NewChildData__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  NewChildData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  NewChildData *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_NewChildData,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewChildData" "', argument " "1"" of type '" "NewChildData const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NewChildData" "', argument " "1"" of type '" "NewChildData const &""'"); 
  }
  arg1 = reinterpret_cast< NewChildData * >(argp1);
  result = (NewChildData *)new NewChildData((NewChildData const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NewChildData, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_NewChildData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_NewChildData",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_NewChildData__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_NewChildData__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NewChildData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    NewChildData::NewChildData()\n"
    "    NewChildData::NewChildData(NewChildData const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_NewChildData_processId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewChildData *arg1 = (NewChildData *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewChildData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewChildData_processId_set" "', argument " "1"" of type '" "NewChildData *""'"); 
  }
  arg1 = reinterpret_cast< NewChildData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewChildData_processId_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->processId = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewChildData_processId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewChildData *arg1 = (NewChildData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"NewChildData_processId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewChildData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewChildData_processId_get" "', argument " "1"" of type '" "NewChildData *""'"); 
  }
  arg1 = reinterpret_cast< NewChildData * >(argp1);
  result = (uint32_t) ((arg1)->processId);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewChildData_ident_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewChildData *arg1 = (NewChildData *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewChildData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewChildData_ident_set" "', argument " "1"" of type '" "NewChildData *""'"); 
  }
  arg1 = reinterpret_cast< NewChildData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewChildData_ident_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->ident = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewChildData_ident_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewChildData *arg1 = (NewChildData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"NewChildData_ident_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewChildData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewChildData_ident_get" "', argument " "1"" of type '" "NewChildData *""'"); 
  }
  arg1 = reinterpret_cast< NewChildData * >(argp1);
  result = (uint32_t) ((arg1)->ident);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NewChildData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewChildData *arg1 = (NewChildData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_NewChildData",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NewChildData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewChildData" "', argument " "1"" of type '" "NewChildData *""'"); 
  }
  arg1 = reinterpret_cast< NewChildData * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_NewChildData) /* defines _wrap_delete_NewChildData_destructor_closure */

SWIGINTERN int _wrap_new_TargetControlMessage__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TargetControlMessage *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (TargetControlMessage *)new TargetControlMessage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TargetControlMessage, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TargetControlMessage__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TargetControlMessage *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TargetControlMessage,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TargetControlMessage" "', argument " "1"" of type '" "TargetControlMessage const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TargetControlMessage" "', argument " "1"" of type '" "TargetControlMessage const &""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  result = (TargetControlMessage *)new TargetControlMessage((TargetControlMessage const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TargetControlMessage, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TargetControlMessage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_TargetControlMessage",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TargetControlMessage__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_TargetControlMessage__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TargetControlMessage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TargetControlMessage::TargetControlMessage()\n"
    "    TargetControlMessage::TargetControlMessage(TargetControlMessage const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  TargetControlMessageType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_type_set" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TargetControlMessage_type_set" "', argument " "2"" of type '" "TargetControlMessageType""'");
  } 
  arg2 = static_cast< TargetControlMessageType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TargetControlMessageType result;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControlMessage_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_type_get" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  result = (TargetControlMessageType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_TargetControlMessageType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_newCapture_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  NewCaptureData *arg2 = (NewCaptureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_newCapture_set" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TargetControlMessage_newCapture_set" "', argument " "2"" of type '" "NewCaptureData *""'"); 
  }
  arg2 = reinterpret_cast< NewCaptureData * >(argp2);
  if (arg1) (arg1)->newCapture = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_newCapture_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  NewCaptureData *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControlMessage_newCapture_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_newCapture_get" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  result = (NewCaptureData *)& ((arg1)->newCapture);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NewCaptureData, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_apiUse_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  APIUseData *arg2 = (APIUseData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_apiUse_set" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_APIUseData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TargetControlMessage_apiUse_set" "', argument " "2"" of type '" "APIUseData *""'"); 
  }
  arg2 = reinterpret_cast< APIUseData * >(argp2);
  if (arg1) (arg1)->apiUse = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_apiUse_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  APIUseData *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControlMessage_apiUse_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_apiUse_get" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  result = (APIUseData *)& ((arg1)->apiUse);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_APIUseData, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_busy_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  BusyData *arg2 = (BusyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_busy_set" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_BusyData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TargetControlMessage_busy_set" "', argument " "2"" of type '" "BusyData *""'"); 
  }
  arg2 = reinterpret_cast< BusyData * >(argp2);
  if (arg1) (arg1)->busy = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_busy_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BusyData *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControlMessage_busy_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_busy_get" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  result = (BusyData *)& ((arg1)->busy);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BusyData, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_newChild_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  NewChildData *arg2 = (NewChildData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_newChild_set" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_NewChildData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TargetControlMessage_newChild_set" "', argument " "2"" of type '" "NewChildData *""'"); 
  }
  arg2 = reinterpret_cast< NewChildData * >(argp2);
  if (arg1) (arg1)->newChild = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_newChild_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  NewChildData *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControlMessage_newChild_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_newChild_get" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  result = (NewChildData *)& ((arg1)->newChild);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NewChildData, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_capProgress_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_capProgress_set" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TargetControlMessage_capProgress_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->capProgress = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_capProgress_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControlMessage_capProgress_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_capProgress_get" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  result = (float) ((arg1)->capProgress);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_capturableWindowCount_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_capturableWindowCount_set" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TargetControlMessage_capturableWindowCount_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->capturableWindowCount = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TargetControlMessage_capturableWindowCount_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TargetControlMessage_capturableWindowCount_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TargetControlMessage_capturableWindowCount_get" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  result = (uint32_t) ((arg1)->capturableWindowCount);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TargetControlMessage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessage *arg1 = (TargetControlMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TargetControlMessage",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TargetControlMessage" "', argument " "1"" of type '" "TargetControlMessage *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessage * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TargetControlMessage) /* defines _wrap_delete_TargetControlMessage_destructor_closure */

SWIGINTERN int _wrap_new_EnvironmentModification__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EnvironmentModification *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (EnvironmentModification *)new EnvironmentModification();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EnvironmentModification, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_EnvironmentModification__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  EnvironmentModification *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EnvironmentModification *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_EnvironmentModification,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EnvironmentModification" "', argument " "1"" of type '" "EnvironmentModification const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EnvironmentModification" "', argument " "1"" of type '" "EnvironmentModification const &""'"); 
  }
  arg1 = reinterpret_cast< EnvironmentModification * >(argp1);
  result = (EnvironmentModification *)new EnvironmentModification((EnvironmentModification const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EnvironmentModification, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_EnvironmentModification__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  EnvMod arg1 ;
  EnvSep arg2 ;
  rdcstr *arg3 = 0 ;
  rdcstr *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  rdcstr temp3 ;
  rdcstr temp4 ;
  EnvironmentModification *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EnvironmentModification" "', argument " "1"" of type '" "EnvMod""'");
  } 
  arg1 = static_cast< EnvMod >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EnvironmentModification" "', argument " "2"" of type '" "EnvSep""'");
  } 
  arg2 = static_cast< EnvSep >(val2);
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[2], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_EnvironmentModification' argument 3 of type 'rdcstr'"); 
    }
  }
  {
    tempset(arg4, &temp4);
    
    int res = ConvertFromPy(swig_obj[3], indirect(arg4));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_EnvironmentModification' argument 4 of type 'rdcstr'"); 
    }
  }
  result = (EnvironmentModification *)new EnvironmentModification(arg1,arg2,(rdcstr const &)*arg3,(rdcstr const &)*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EnvironmentModification, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_EnvironmentModification(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EnvironmentModification",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EnvironmentModification__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_EnvironmentModification__SWIG_1(self, argc, argv);
  }
  if (argc == 4) {
    return _wrap_new_EnvironmentModification__SWIG_2(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EnvironmentModification'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EnvironmentModification::EnvironmentModification()\n"
    "    EnvironmentModification::EnvironmentModification(EnvironmentModification const &)\n"
    "    EnvironmentModification::EnvironmentModification(EnvMod,EnvSep,rdcstr const &,rdcstr const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_EnvironmentModification___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvironmentModification *arg1 = (EnvironmentModification *) 0 ;
  EnvironmentModification *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvironmentModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EnvironmentModification___lt__" "', argument " "1"" of type '" "EnvironmentModification const *""'"); 
  }
  arg1 = reinterpret_cast< EnvironmentModification * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_EnvironmentModification,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EnvironmentModification___lt__" "', argument " "2"" of type '" "EnvironmentModification const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EnvironmentModification___lt__" "', argument " "2"" of type '" "EnvironmentModification const &""'"); 
  }
  arg2 = reinterpret_cast< EnvironmentModification * >(argp2);
  result = (bool)((EnvironmentModification const *)arg1)->operator <((EnvironmentModification const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EnvironmentModification_mod_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvironmentModification *arg1 = (EnvironmentModification *) 0 ;
  EnvMod arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvironmentModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EnvironmentModification_mod_set" "', argument " "1"" of type '" "EnvironmentModification *""'"); 
  }
  arg1 = reinterpret_cast< EnvironmentModification * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EnvironmentModification_mod_set" "', argument " "2"" of type '" "EnvMod""'");
  } 
  arg2 = static_cast< EnvMod >(val2);
  if (arg1) (arg1)->mod = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EnvironmentModification_mod_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvironmentModification *arg1 = (EnvironmentModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  EnvMod result;
  
  if (!SWIG_Python_UnpackTuple(args,"EnvironmentModification_mod_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvironmentModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EnvironmentModification_mod_get" "', argument " "1"" of type '" "EnvironmentModification *""'"); 
  }
  arg1 = reinterpret_cast< EnvironmentModification * >(argp1);
  result = (EnvMod) ((arg1)->mod);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_EnvMod->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EnvironmentModification_sep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvironmentModification *arg1 = (EnvironmentModification *) 0 ;
  EnvSep arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvironmentModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EnvironmentModification_sep_set" "', argument " "1"" of type '" "EnvironmentModification *""'"); 
  }
  arg1 = reinterpret_cast< EnvironmentModification * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EnvironmentModification_sep_set" "', argument " "2"" of type '" "EnvSep""'");
  } 
  arg2 = static_cast< EnvSep >(val2);
  if (arg1) (arg1)->sep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EnvironmentModification_sep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvironmentModification *arg1 = (EnvironmentModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  EnvSep result;
  
  if (!SWIG_Python_UnpackTuple(args,"EnvironmentModification_sep_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvironmentModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EnvironmentModification_sep_get" "', argument " "1"" of type '" "EnvironmentModification *""'"); 
  }
  arg1 = reinterpret_cast< EnvironmentModification * >(argp1);
  result = (EnvSep) ((arg1)->sep);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_EnvSep->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EnvironmentModification_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvironmentModification *arg1 = (EnvironmentModification *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvironmentModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EnvironmentModification_name_set" "', argument " "1"" of type '" "EnvironmentModification *""'"); 
  }
  arg1 = reinterpret_cast< EnvironmentModification * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'EnvironmentModification_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EnvironmentModification_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvironmentModification *arg1 = (EnvironmentModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"EnvironmentModification_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvironmentModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EnvironmentModification_name_get" "', argument " "1"" of type '" "EnvironmentModification *""'"); 
  }
  arg1 = reinterpret_cast< EnvironmentModification * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EnvironmentModification_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvironmentModification *arg1 = (EnvironmentModification *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvironmentModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EnvironmentModification_value_set" "', argument " "1"" of type '" "EnvironmentModification *""'"); 
  }
  arg1 = reinterpret_cast< EnvironmentModification * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'EnvironmentModification_value_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EnvironmentModification_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvironmentModification *arg1 = (EnvironmentModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"EnvironmentModification_value_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvironmentModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EnvironmentModification_value_get" "', argument " "1"" of type '" "EnvironmentModification *""'"); 
  }
  arg1 = reinterpret_cast< EnvironmentModification * >(argp1);
  result =  ((arg1)->value);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EnvironmentModification___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvironmentModification *arg1 = (EnvironmentModification *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvironmentModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EnvironmentModification___eq__" "', argument " "1"" of type '" "EnvironmentModification *""'"); 
  }
  arg1 = reinterpret_cast< EnvironmentModification * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)EnvironmentModification___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EnvironmentModification___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvironmentModification *arg1 = (EnvironmentModification *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvironmentModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EnvironmentModification___ne__" "', argument " "1"" of type '" "EnvironmentModification *""'"); 
  }
  arg1 = reinterpret_cast< EnvironmentModification * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)EnvironmentModification___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EnvironmentModification(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvironmentModification *arg1 = (EnvironmentModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_EnvironmentModification",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvironmentModification, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EnvironmentModification" "', argument " "1"" of type '" "EnvironmentModification *""'"); 
  }
  arg1 = reinterpret_cast< EnvironmentModification * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_EnvironmentModification) /* defines _wrap_delete_EnvironmentModification_destructor_closure */

SWIGINTERN int _wrap_new_CaptureFileFormat__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  CaptureFileFormat *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (CaptureFileFormat *)new CaptureFileFormat();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CaptureFileFormat, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_CaptureFileFormat__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  CaptureFileFormat *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_CaptureFileFormat,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CaptureFileFormat" "', argument " "1"" of type '" "CaptureFileFormat const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CaptureFileFormat" "', argument " "1"" of type '" "CaptureFileFormat const &""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  result = (CaptureFileFormat *)new CaptureFileFormat((CaptureFileFormat const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CaptureFileFormat, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_CaptureFileFormat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_CaptureFileFormat",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CaptureFileFormat__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_CaptureFileFormat__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CaptureFileFormat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CaptureFileFormat::CaptureFileFormat()\n"
    "    CaptureFileFormat::CaptureFileFormat(CaptureFileFormat const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  CaptureFileFormat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat___lt__" "', argument " "1"" of type '" "CaptureFileFormat const *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_CaptureFileFormat,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CaptureFileFormat___lt__" "', argument " "2"" of type '" "CaptureFileFormat const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CaptureFileFormat___lt__" "', argument " "2"" of type '" "CaptureFileFormat const &""'"); 
  }
  arg2 = reinterpret_cast< CaptureFileFormat * >(argp2);
  result = (bool)((CaptureFileFormat const *)arg1)->operator <((CaptureFileFormat const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat_extension_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat_extension_set" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureFileFormat_extension_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->extension = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat_extension_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFileFormat_extension_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat_extension_get" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  result =  ((arg1)->extension);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat_name_set" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureFileFormat_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFileFormat_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat_name_get" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat_description_set" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CaptureFileFormat_description_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->description = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFileFormat_description_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat_description_get" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  result =  ((arg1)->description);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat_requiresBuffers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat_requiresBuffers_set" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureFileFormat_requiresBuffers_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->requiresBuffers = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat_requiresBuffers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFileFormat_requiresBuffers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat_requiresBuffers_get" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  result = (bool) ((arg1)->requiresBuffers);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat_openSupported_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat_openSupported_set" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureFileFormat_openSupported_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->openSupported = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat_openSupported_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFileFormat_openSupported_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat_openSupported_get" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  result = (bool) ((arg1)->openSupported);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat_convertSupported_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat_convertSupported_set" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CaptureFileFormat_convertSupported_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->convertSupported = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat_convertSupported_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"CaptureFileFormat_convertSupported_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat_convertSupported_get" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  result = (bool) ((arg1)->convertSupported);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat___eq__" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)CaptureFileFormat___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CaptureFileFormat___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CaptureFileFormat___ne__" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)CaptureFileFormat___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CaptureFileFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CaptureFileFormat *arg1 = (CaptureFileFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_CaptureFileFormat",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CaptureFileFormat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CaptureFileFormat" "', argument " "1"" of type '" "CaptureFileFormat *""'"); 
  }
  arg1 = reinterpret_cast< CaptureFileFormat * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CaptureFileFormat) /* defines _wrap_delete_CaptureFileFormat_destructor_closure */

SWIGINTERN int _wrap_new_GPUDevice__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GPUDevice *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GPUDevice *)new GPUDevice();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GPUDevice, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GPUDevice__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GPUDevice *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GPUDevice,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GPUDevice" "', argument " "1"" of type '" "GPUDevice const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GPUDevice" "', argument " "1"" of type '" "GPUDevice const &""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  result = (GPUDevice *)new GPUDevice((GPUDevice const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GPUDevice, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GPUDevice(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GPUDevice",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GPUDevice__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GPUDevice__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GPUDevice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GPUDevice::GPUDevice()\n"
    "    GPUDevice::GPUDevice(GPUDevice const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GPUDevice___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = (GPUDevice *) 0 ;
  GPUDevice *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPUDevice___eq__" "', argument " "1"" of type '" "GPUDevice const *""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_GPUDevice,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GPUDevice___eq__" "', argument " "2"" of type '" "GPUDevice const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GPUDevice___eq__" "', argument " "2"" of type '" "GPUDevice const &""'"); 
  }
  arg2 = reinterpret_cast< GPUDevice * >(argp2);
  result = (bool)((GPUDevice const *)arg1)->operator ==((GPUDevice const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GPUDevice___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = (GPUDevice *) 0 ;
  GPUDevice *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPUDevice___lt__" "', argument " "1"" of type '" "GPUDevice const *""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_GPUDevice,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GPUDevice___lt__" "', argument " "2"" of type '" "GPUDevice const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GPUDevice___lt__" "', argument " "2"" of type '" "GPUDevice const &""'"); 
  }
  arg2 = reinterpret_cast< GPUDevice * >(argp2);
  result = (bool)((GPUDevice const *)arg1)->operator <((GPUDevice const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GPUDevice_vendor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = (GPUDevice *) 0 ;
  GPUVendor arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPUDevice_vendor_set" "', argument " "1"" of type '" "GPUDevice *""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GPUDevice_vendor_set" "', argument " "2"" of type '" "GPUVendor""'");
  } 
  arg2 = static_cast< GPUVendor >(val2);
  if (arg1) (arg1)->vendor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GPUDevice_vendor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = (GPUDevice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GPUVendor result;
  
  if (!SWIG_Python_UnpackTuple(args,"GPUDevice_vendor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPUDevice_vendor_get" "', argument " "1"" of type '" "GPUDevice *""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  result = (GPUVendor) ((arg1)->vendor);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_GPUVendor->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GPUDevice_deviceID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = (GPUDevice *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPUDevice_deviceID_set" "', argument " "1"" of type '" "GPUDevice *""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GPUDevice_deviceID_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->deviceID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GPUDevice_deviceID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = (GPUDevice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GPUDevice_deviceID_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPUDevice_deviceID_get" "', argument " "1"" of type '" "GPUDevice *""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  result = (uint32_t) ((arg1)->deviceID);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GPUDevice_driver_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = (GPUDevice *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPUDevice_driver_set" "', argument " "1"" of type '" "GPUDevice *""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'GPUDevice_driver_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->driver = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GPUDevice_driver_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = (GPUDevice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"GPUDevice_driver_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPUDevice_driver_get" "', argument " "1"" of type '" "GPUDevice *""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  result =  ((arg1)->driver);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GPUDevice_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = (GPUDevice *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPUDevice_name_set" "', argument " "1"" of type '" "GPUDevice *""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'GPUDevice_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GPUDevice_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = (GPUDevice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"GPUDevice_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPUDevice_name_get" "', argument " "1"" of type '" "GPUDevice *""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GPUDevice_apis_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = (GPUDevice *) 0 ;
  rdcarray< GraphicsAPI > *arg2 = (rdcarray< GraphicsAPI > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPUDevice_apis_set" "', argument " "1"" of type '" "GPUDevice *""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GPUDevice_apis_set' argument 2 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GPUDevice_apis_set' argument 2 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->apis = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GPUDevice_apis_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = (GPUDevice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< GraphicsAPI > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GPUDevice_apis_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GPUDevice_apis_get" "', argument " "1"" of type '" "GPUDevice *""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  result = (rdcarray< GraphicsAPI > *)& ((arg1)->apis);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_GraphicsAPI_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GPUDevice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUDevice *arg1 = (GPUDevice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GPUDevice",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUDevice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GPUDevice" "', argument " "1"" of type '" "GPUDevice *""'"); 
  }
  arg1 = reinterpret_cast< GPUDevice * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GPUDevice) /* defines _wrap_delete_GPUDevice_destructor_closure */

SWIGINTERN int _wrap_new_ReplayOptions__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ReplayOptions *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ReplayOptions *)new ReplayOptions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ReplayOptions, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ReplayOptions__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ReplayOptions *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ReplayOptions *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ReplayOptions,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ReplayOptions" "', argument " "1"" of type '" "ReplayOptions const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ReplayOptions" "', argument " "1"" of type '" "ReplayOptions const &""'"); 
  }
  arg1 = reinterpret_cast< ReplayOptions * >(argp1);
  result = (ReplayOptions *)new ReplayOptions((ReplayOptions const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ReplayOptions, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ReplayOptions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ReplayOptions",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ReplayOptions__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ReplayOptions__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ReplayOptions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ReplayOptions::ReplayOptions()\n"
    "    ReplayOptions::ReplayOptions(ReplayOptions const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ReplayOptions_apiValidation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOptions *arg1 = (ReplayOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplayOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOptions_apiValidation_set" "', argument " "1"" of type '" "ReplayOptions *""'"); 
  }
  arg1 = reinterpret_cast< ReplayOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReplayOptions_apiValidation_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->apiValidation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOptions_apiValidation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOptions *arg1 = (ReplayOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOptions_apiValidation_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplayOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOptions_apiValidation_get" "', argument " "1"" of type '" "ReplayOptions *""'"); 
  }
  arg1 = reinterpret_cast< ReplayOptions * >(argp1);
  result = (bool) ((arg1)->apiValidation);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOptions_forceGPUVendor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOptions *arg1 = (ReplayOptions *) 0 ;
  GPUVendor arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplayOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOptions_forceGPUVendor_set" "', argument " "1"" of type '" "ReplayOptions *""'"); 
  }
  arg1 = reinterpret_cast< ReplayOptions * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReplayOptions_forceGPUVendor_set" "', argument " "2"" of type '" "GPUVendor""'");
  } 
  arg2 = static_cast< GPUVendor >(val2);
  if (arg1) (arg1)->forceGPUVendor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOptions_forceGPUVendor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOptions *arg1 = (ReplayOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GPUVendor result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOptions_forceGPUVendor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplayOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOptions_forceGPUVendor_get" "', argument " "1"" of type '" "ReplayOptions *""'"); 
  }
  arg1 = reinterpret_cast< ReplayOptions * >(argp1);
  result = (GPUVendor) ((arg1)->forceGPUVendor);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_GPUVendor->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOptions_forceGPUDeviceID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOptions *arg1 = (ReplayOptions *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplayOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOptions_forceGPUDeviceID_set" "', argument " "1"" of type '" "ReplayOptions *""'"); 
  }
  arg1 = reinterpret_cast< ReplayOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReplayOptions_forceGPUDeviceID_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->forceGPUDeviceID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOptions_forceGPUDeviceID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOptions *arg1 = (ReplayOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOptions_forceGPUDeviceID_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplayOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOptions_forceGPUDeviceID_get" "', argument " "1"" of type '" "ReplayOptions *""'"); 
  }
  arg1 = reinterpret_cast< ReplayOptions * >(argp1);
  result = (uint32_t) ((arg1)->forceGPUDeviceID);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOptions_forceGPUDriverName_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOptions *arg1 = (ReplayOptions *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplayOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOptions_forceGPUDriverName_set" "', argument " "1"" of type '" "ReplayOptions *""'"); 
  }
  arg1 = reinterpret_cast< ReplayOptions * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ReplayOptions_forceGPUDriverName_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->forceGPUDriverName = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOptions_forceGPUDriverName_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOptions *arg1 = (ReplayOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOptions_forceGPUDriverName_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplayOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOptions_forceGPUDriverName_get" "', argument " "1"" of type '" "ReplayOptions *""'"); 
  }
  arg1 = reinterpret_cast< ReplayOptions * >(argp1);
  result =  ((arg1)->forceGPUDriverName);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOptions_optimisation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOptions *arg1 = (ReplayOptions *) 0 ;
  ReplayOptimisationLevel arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplayOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOptions_optimisation_set" "', argument " "1"" of type '" "ReplayOptions *""'"); 
  }
  arg1 = reinterpret_cast< ReplayOptions * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReplayOptions_optimisation_set" "', argument " "2"" of type '" "ReplayOptimisationLevel""'");
  } 
  arg2 = static_cast< ReplayOptimisationLevel >(val2);
  if (arg1) (arg1)->optimisation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReplayOptions_optimisation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOptions *arg1 = (ReplayOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ReplayOptimisationLevel result;
  
  if (!SWIG_Python_UnpackTuple(args,"ReplayOptions_optimisation_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplayOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReplayOptions_optimisation_get" "', argument " "1"" of type '" "ReplayOptions *""'"); 
  }
  arg1 = reinterpret_cast< ReplayOptions * >(argp1);
  result = (ReplayOptimisationLevel) ((arg1)->optimisation);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ReplayOptimisationLevel->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ReplayOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOptions *arg1 = (ReplayOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ReplayOptions",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplayOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReplayOptions" "', argument " "1"" of type '" "ReplayOptions *""'"); 
  }
  arg1 = reinterpret_cast< ReplayOptions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ReplayOptions) /* defines _wrap_delete_ReplayOptions_destructor_closure */

SWIGINTERN int _wrap_new_WindowingData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  WindowingData *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_WindowingData",0,0,0)) SWIG_fail;
  result = (WindowingData *)new WindowingData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_WindowingData, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_WindowingData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  WindowingData *arg1 = (WindowingData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_WindowingData",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_WindowingData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowingData" "', argument " "1"" of type '" "WindowingData *""'"); 
  }
  arg1 = reinterpret_cast< WindowingData * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_WindowingData) /* defines _wrap_delete_WindowingData_destructor_closure */

SWIGINTERN int _wrap_new_GlobalEnvironment__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GlobalEnvironment *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GlobalEnvironment *)new GlobalEnvironment();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GlobalEnvironment, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GlobalEnvironment__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GlobalEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GlobalEnvironment *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GlobalEnvironment,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GlobalEnvironment" "', argument " "1"" of type '" "GlobalEnvironment const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GlobalEnvironment" "', argument " "1"" of type '" "GlobalEnvironment const &""'"); 
  }
  arg1 = reinterpret_cast< GlobalEnvironment * >(argp1);
  result = (GlobalEnvironment *)new GlobalEnvironment((GlobalEnvironment const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GlobalEnvironment, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GlobalEnvironment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GlobalEnvironment",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GlobalEnvironment__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GlobalEnvironment__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GlobalEnvironment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GlobalEnvironment::GlobalEnvironment()\n"
    "    GlobalEnvironment::GlobalEnvironment(GlobalEnvironment const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GlobalEnvironment_xlibDisplay_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GlobalEnvironment *arg1 = (GlobalEnvironment *) 0 ;
  Display *arg2 = (Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long tmp2 ;
  int err2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GlobalEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GlobalEnvironment_xlibDisplay_set" "', argument " "1"" of type '" "GlobalEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< GlobalEnvironment * >(argp1);
  {
    // convert windowing data pointers from just plain integers
    err2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[0], &tmp2);
    if (!SWIG_IsOK(err2)) {
      SWIG_exception_fail(SWIG_ArgError(err2), "in method '" "GlobalEnvironment_xlibDisplay_set" "', argument " "2"" of type '" "Display""'");
    } 
    arg2 = (Display *)tmp2;
  }
  if (arg1) (arg1)->xlibDisplay = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalEnvironment_xlibDisplay_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GlobalEnvironment *arg1 = (GlobalEnvironment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Display *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GlobalEnvironment_xlibDisplay_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GlobalEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GlobalEnvironment_xlibDisplay_get" "', argument " "1"" of type '" "GlobalEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< GlobalEnvironment * >(argp1);
  result = (Display *) ((arg1)->xlibDisplay);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__XDisplay, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalEnvironment_waylandDisplay_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GlobalEnvironment *arg1 = (GlobalEnvironment *) 0 ;
  wl_display *arg2 = (wl_display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GlobalEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GlobalEnvironment_waylandDisplay_set" "', argument " "1"" of type '" "GlobalEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< GlobalEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_wl_display, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GlobalEnvironment_waylandDisplay_set" "', argument " "2"" of type '" "wl_display *""'"); 
  }
  arg2 = reinterpret_cast< wl_display * >(argp2);
  if (arg1) (arg1)->waylandDisplay = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalEnvironment_waylandDisplay_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GlobalEnvironment *arg1 = (GlobalEnvironment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  wl_display *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GlobalEnvironment_waylandDisplay_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GlobalEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GlobalEnvironment_waylandDisplay_get" "', argument " "1"" of type '" "GlobalEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< GlobalEnvironment * >(argp1);
  result = (wl_display *) ((arg1)->waylandDisplay);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wl_display, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalEnvironment_enumerateGPUs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GlobalEnvironment *arg1 = (GlobalEnvironment *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GlobalEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GlobalEnvironment_enumerateGPUs_set" "', argument " "1"" of type '" "GlobalEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< GlobalEnvironment * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GlobalEnvironment_enumerateGPUs_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->enumerateGPUs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalEnvironment_enumerateGPUs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GlobalEnvironment *arg1 = (GlobalEnvironment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GlobalEnvironment_enumerateGPUs_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GlobalEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GlobalEnvironment_enumerateGPUs_get" "', argument " "1"" of type '" "GlobalEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< GlobalEnvironment * >(argp1);
  result = (bool) ((arg1)->enumerateGPUs);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GlobalEnvironment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GlobalEnvironment *arg1 = (GlobalEnvironment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GlobalEnvironment",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GlobalEnvironment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GlobalEnvironment" "', argument " "1"" of type '" "GlobalEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< GlobalEnvironment * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GlobalEnvironment) /* defines _wrap_delete_GlobalEnvironment_destructor_closure */

SWIGINTERN PyObject *_wrap_ResultDetails_OK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResultDetails *arg1 = (ResultDetails *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResultDetails_OK",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResultDetails, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResultDetails_OK" "', argument " "1"" of type '" "ResultDetails const *""'"); 
  }
  arg1 = reinterpret_cast< ResultDetails * >(argp1);
  result = (bool)((ResultDetails const *)arg1)->OK();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResultDetails___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResultDetails *arg1 = (ResultDetails *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResultDetails___nonzero__",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResultDetails, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResultDetails___nonzero__" "', argument " "1"" of type '" "ResultDetails const *""'"); 
  }
  arg1 = reinterpret_cast< ResultDetails * >(argp1);
  result = (bool)((ResultDetails const *)arg1)->operator bool();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResultDetails___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResultDetails *arg1 = (ResultDetails *) 0 ;
  ResultCode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResultDetails, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResultDetails___eq__" "', argument " "1"" of type '" "ResultDetails const *""'"); 
  }
  arg1 = reinterpret_cast< ResultDetails * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResultDetails___eq__" "', argument " "2"" of type '" "ResultCode""'");
  } 
  arg2 = static_cast< ResultCode >(val2);
  result = (bool)((ResultDetails const *)arg1)->operator ==(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResultDetails___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResultDetails *arg1 = (ResultDetails *) 0 ;
  ResultCode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResultDetails, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResultDetails___ne__" "', argument " "1"" of type '" "ResultDetails const *""'"); 
  }
  arg1 = reinterpret_cast< ResultDetails * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResultDetails___ne__" "', argument " "2"" of type '" "ResultCode""'");
  } 
  arg2 = static_cast< ResultCode >(val2);
  result = (bool)((ResultDetails const *)arg1)->operator !=(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResultDetails_code_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResultDetails *arg1 = (ResultDetails *) 0 ;
  ResultCode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResultDetails, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResultDetails_code_set" "', argument " "1"" of type '" "ResultDetails *""'"); 
  }
  arg1 = reinterpret_cast< ResultDetails * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResultDetails_code_set" "', argument " "2"" of type '" "ResultCode""'");
  } 
  arg2 = static_cast< ResultCode >(val2);
  if (arg1) (arg1)->code = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResultDetails_code_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResultDetails *arg1 = (ResultDetails *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResultCode result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResultDetails_code_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResultDetails, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResultDetails_code_get" "', argument " "1"" of type '" "ResultDetails *""'"); 
  }
  arg1 = reinterpret_cast< ResultDetails * >(argp1);
  result = (ResultCode) ((arg1)->code);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ResultCode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResultDetails_Message(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResultDetails *arg1 = (ResultDetails *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResultDetails_Message",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResultDetails, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResultDetails_Message" "', argument " "1"" of type '" "ResultDetails const *""'"); 
  }
  arg1 = reinterpret_cast< ResultDetails * >(argp1);
  result = ((ResultDetails const *)arg1)->Message();
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResultDetails(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResultDetails *arg1 = (ResultDetails *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ResultDetails",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResultDetails, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResultDetails" "', argument " "1"" of type '" "ResultDetails *""'"); 
  }
  arg1 = reinterpret_cast< ResultDetails * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_INQUIRY_CLOSURE(_wrap_ResultDetails___nonzero__) /* defines _wrap_ResultDetails___nonzero___inquiry_closure */

SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ResultDetails) /* defines _wrap_delete_ResultDetails_destructor_closure */

SWIGINTERN int _wrap_new_ExecuteResult__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ExecuteResult *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ExecuteResult *)new ExecuteResult();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ExecuteResult, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ExecuteResult__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ExecuteResult *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ExecuteResult *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ExecuteResult,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecuteResult" "', argument " "1"" of type '" "ExecuteResult const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecuteResult" "', argument " "1"" of type '" "ExecuteResult const &""'"); 
  }
  arg1 = reinterpret_cast< ExecuteResult * >(argp1);
  result = (ExecuteResult *)new ExecuteResult((ExecuteResult const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ExecuteResult, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ExecuteResult(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ExecuteResult",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ExecuteResult__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ExecuteResult__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExecuteResult'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ExecuteResult::ExecuteResult()\n"
    "    ExecuteResult::ExecuteResult(ExecuteResult const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ExecuteResult_result_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExecuteResult *arg1 = (ExecuteResult *) 0 ;
  ResultDetails *arg2 = (ResultDetails *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ExecuteResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExecuteResult_result_set" "', argument " "1"" of type '" "ExecuteResult *""'"); 
  }
  arg1 = reinterpret_cast< ExecuteResult * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResultDetails, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExecuteResult_result_set" "', argument " "2"" of type '" "ResultDetails *""'"); 
  }
  arg2 = reinterpret_cast< ResultDetails * >(argp2);
  if (arg1) (arg1)->result = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExecuteResult_result_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExecuteResult *arg1 = (ExecuteResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResultDetails *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ExecuteResult_result_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ExecuteResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExecuteResult_result_get" "', argument " "1"" of type '" "ExecuteResult *""'"); 
  }
  arg1 = reinterpret_cast< ExecuteResult * >(argp1);
  result = (ResultDetails *)& ((arg1)->result);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResultDetails, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExecuteResult_ident_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExecuteResult *arg1 = (ExecuteResult *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ExecuteResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExecuteResult_ident_set" "', argument " "1"" of type '" "ExecuteResult *""'"); 
  }
  arg1 = reinterpret_cast< ExecuteResult * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExecuteResult_ident_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->ident = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExecuteResult_ident_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExecuteResult *arg1 = (ExecuteResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ExecuteResult_ident_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ExecuteResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExecuteResult_ident_get" "', argument " "1"" of type '" "ExecuteResult *""'"); 
  }
  arg1 = reinterpret_cast< ExecuteResult * >(argp1);
  result = (uint32_t) ((arg1)->ident);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ExecuteResult(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExecuteResult *arg1 = (ExecuteResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ExecuteResult",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ExecuteResult, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExecuteResult" "', argument " "1"" of type '" "ExecuteResult *""'"); 
  }
  arg1 = reinterpret_cast< ExecuteResult * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ExecuteResult) /* defines _wrap_delete_ExecuteResult_destructor_closure */

SWIGINTERN int _wrap_new_Viewport__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Viewport *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (Viewport *)new Viewport();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Viewport, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Viewport__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  bool arg7 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  Viewport *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Viewport" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Viewport" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Viewport" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Viewport" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Viewport" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Viewport" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Viewport" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  result = (Viewport *)new Viewport(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Viewport, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Viewport__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  Viewport *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Viewport" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Viewport" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Viewport" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Viewport" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Viewport" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Viewport" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  result = (Viewport *)new Viewport(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Viewport, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Viewport__SWIG_3(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Viewport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Viewport *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Viewport,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Viewport" "', argument " "1"" of type '" "Viewport const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Viewport" "', argument " "1"" of type '" "Viewport const &""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  result = (Viewport *)new Viewport((Viewport const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Viewport, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Viewport(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Viewport",0,7,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Viewport__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_Viewport__SWIG_3(self, argc, argv);
  }
  if (argc == 6) {
    return _wrap_new_Viewport__SWIG_2(self, argc, argv);
  }
  if (argc == 7) {
    return _wrap_new_Viewport__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Viewport'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Viewport::Viewport()\n"
    "    Viewport::Viewport(float,float,float,float,float,float,bool)\n"
    "    Viewport::Viewport(float,float,float,float,float,float)\n"
    "    Viewport::Viewport(Viewport const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_Viewport___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  Viewport *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport___lt__" "', argument " "1"" of type '" "Viewport const *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_Viewport,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Viewport___lt__" "', argument " "2"" of type '" "Viewport const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Viewport___lt__" "', argument " "2"" of type '" "Viewport const &""'"); 
  }
  arg2 = reinterpret_cast< Viewport * >(argp2);
  result = (bool)((Viewport const *)arg1)->operator <((Viewport const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_enabled_set" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Viewport_enabled_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Viewport_enabled_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_enabled_get" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  result = (bool) ((arg1)->enabled);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_x_set" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Viewport_x_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"Viewport_x_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_x_get" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  result = (float) ((arg1)->x);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_y_set" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Viewport_y_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"Viewport_y_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_y_get" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  result = (float) ((arg1)->y);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_width_set" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Viewport_width_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"Viewport_width_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_width_get" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  result = (float) ((arg1)->width);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_height_set" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Viewport_height_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"Viewport_height_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_height_get" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  result = (float) ((arg1)->height);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_minDepth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_minDepth_set" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Viewport_minDepth_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->minDepth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_minDepth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"Viewport_minDepth_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_minDepth_get" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  result = (float) ((arg1)->minDepth);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_maxDepth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_maxDepth_set" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Viewport_maxDepth_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->maxDepth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport_maxDepth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"Viewport_maxDepth_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport_maxDepth_get" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  result = (float) ((arg1)->maxDepth);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport___eq__" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)Viewport___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Viewport___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Viewport___ne__" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)Viewport___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Viewport(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Viewport *arg1 = (Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_Viewport",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Viewport, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Viewport" "', argument " "1"" of type '" "Viewport *""'"); 
  }
  arg1 = reinterpret_cast< Viewport * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_Viewport) /* defines _wrap_delete_Viewport_destructor_closure */

SWIGINTERN int _wrap_new_Scissor__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Scissor *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (Scissor *)new Scissor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Scissor, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Scissor__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  bool arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Scissor *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Scissor" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Scissor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Scissor" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Scissor" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Scissor" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (Scissor *)new Scissor(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Scissor, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Scissor__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Scissor *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Scissor" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Scissor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Scissor" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Scissor" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Scissor *)new Scissor(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Scissor, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Scissor__SWIG_3(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Scissor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Scissor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Scissor,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Scissor" "', argument " "1"" of type '" "Scissor const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Scissor" "', argument " "1"" of type '" "Scissor const &""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  result = (Scissor *)new Scissor((Scissor const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Scissor, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Scissor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Scissor",0,5,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Scissor__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_Scissor__SWIG_3(self, argc, argv);
  }
  if (argc == 4) {
    return _wrap_new_Scissor__SWIG_2(self, argc, argv);
  }
  if (argc == 5) {
    return _wrap_new_Scissor__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Scissor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Scissor::Scissor()\n"
    "    Scissor::Scissor(int,int,int,int,bool)\n"
    "    Scissor::Scissor(int,int,int,int)\n"
    "    Scissor::Scissor(Scissor const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_Scissor___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  Scissor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scissor___lt__" "', argument " "1"" of type '" "Scissor const *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_Scissor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Scissor___lt__" "', argument " "2"" of type '" "Scissor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Scissor___lt__" "', argument " "2"" of type '" "Scissor const &""'"); 
  }
  arg2 = reinterpret_cast< Scissor * >(argp2);
  result = (bool)((Scissor const *)arg1)->operator <((Scissor const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Scissor_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scissor_x_set" "', argument " "1"" of type '" "Scissor *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Scissor_x_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Scissor_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Scissor_x_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scissor_x_get" "', argument " "1"" of type '" "Scissor *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  result = (int32_t) ((arg1)->x);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Scissor_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scissor_y_set" "', argument " "1"" of type '" "Scissor *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Scissor_y_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Scissor_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Scissor_y_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scissor_y_get" "', argument " "1"" of type '" "Scissor *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  result = (int32_t) ((arg1)->y);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Scissor_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scissor_width_set" "', argument " "1"" of type '" "Scissor *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Scissor_width_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Scissor_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Scissor_width_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scissor_width_get" "', argument " "1"" of type '" "Scissor *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  result = (int32_t) ((arg1)->width);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Scissor_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scissor_height_set" "', argument " "1"" of type '" "Scissor *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Scissor_height_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Scissor_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Scissor_height_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scissor_height_get" "', argument " "1"" of type '" "Scissor *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  result = (int32_t) ((arg1)->height);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Scissor_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scissor_enabled_set" "', argument " "1"" of type '" "Scissor *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Scissor_enabled_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Scissor_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"Scissor_enabled_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scissor_enabled_get" "', argument " "1"" of type '" "Scissor *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  result = (bool) ((arg1)->enabled);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Scissor___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scissor___eq__" "', argument " "1"" of type '" "Scissor *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)Scissor___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Scissor___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scissor___ne__" "', argument " "1"" of type '" "Scissor *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)Scissor___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Scissor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Scissor *arg1 = (Scissor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_Scissor",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Scissor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Scissor" "', argument " "1"" of type '" "Scissor *""'"); 
  }
  arg1 = reinterpret_cast< Scissor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_Scissor) /* defines _wrap_delete_Scissor_destructor_closure */

SWIGINTERN int _wrap_new_BlendEquation__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  BlendEquation *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (BlendEquation *)new BlendEquation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BlendEquation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_BlendEquation__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlendEquation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  BlendEquation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_BlendEquation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlendEquation" "', argument " "1"" of type '" "BlendEquation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlendEquation" "', argument " "1"" of type '" "BlendEquation const &""'"); 
  }
  arg1 = reinterpret_cast< BlendEquation * >(argp1);
  result = (BlendEquation *)new BlendEquation((BlendEquation const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BlendEquation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_BlendEquation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_BlendEquation",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_BlendEquation__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_BlendEquation__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BlendEquation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlendEquation::BlendEquation()\n"
    "    BlendEquation::BlendEquation(BlendEquation const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_BlendEquation___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendEquation *arg1 = (BlendEquation *) 0 ;
  BlendEquation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendEquation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendEquation___eq__" "', argument " "1"" of type '" "BlendEquation const *""'"); 
  }
  arg1 = reinterpret_cast< BlendEquation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_BlendEquation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlendEquation___eq__" "', argument " "2"" of type '" "BlendEquation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlendEquation___eq__" "', argument " "2"" of type '" "BlendEquation const &""'"); 
  }
  arg2 = reinterpret_cast< BlendEquation * >(argp2);
  result = (bool)((BlendEquation const *)arg1)->operator ==((BlendEquation const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendEquation___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendEquation *arg1 = (BlendEquation *) 0 ;
  BlendEquation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendEquation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendEquation___lt__" "', argument " "1"" of type '" "BlendEquation const *""'"); 
  }
  arg1 = reinterpret_cast< BlendEquation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_BlendEquation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlendEquation___lt__" "', argument " "2"" of type '" "BlendEquation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlendEquation___lt__" "', argument " "2"" of type '" "BlendEquation const &""'"); 
  }
  arg2 = reinterpret_cast< BlendEquation * >(argp2);
  result = (bool)((BlendEquation const *)arg1)->operator <((BlendEquation const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendEquation_source_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendEquation *arg1 = (BlendEquation *) 0 ;
  BlendMultiplier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendEquation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendEquation_source_set" "', argument " "1"" of type '" "BlendEquation *""'"); 
  }
  arg1 = reinterpret_cast< BlendEquation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlendEquation_source_set" "', argument " "2"" of type '" "BlendMultiplier""'");
  } 
  arg2 = static_cast< BlendMultiplier >(val2);
  if (arg1) (arg1)->source = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendEquation_source_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendEquation *arg1 = (BlendEquation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BlendMultiplier result;
  
  if (!SWIG_Python_UnpackTuple(args,"BlendEquation_source_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendEquation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendEquation_source_get" "', argument " "1"" of type '" "BlendEquation *""'"); 
  }
  arg1 = reinterpret_cast< BlendEquation * >(argp1);
  result = (BlendMultiplier) ((arg1)->source);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_BlendMultiplier->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendEquation_destination_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendEquation *arg1 = (BlendEquation *) 0 ;
  BlendMultiplier arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendEquation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendEquation_destination_set" "', argument " "1"" of type '" "BlendEquation *""'"); 
  }
  arg1 = reinterpret_cast< BlendEquation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlendEquation_destination_set" "', argument " "2"" of type '" "BlendMultiplier""'");
  } 
  arg2 = static_cast< BlendMultiplier >(val2);
  if (arg1) (arg1)->destination = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendEquation_destination_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendEquation *arg1 = (BlendEquation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BlendMultiplier result;
  
  if (!SWIG_Python_UnpackTuple(args,"BlendEquation_destination_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendEquation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendEquation_destination_get" "', argument " "1"" of type '" "BlendEquation *""'"); 
  }
  arg1 = reinterpret_cast< BlendEquation * >(argp1);
  result = (BlendMultiplier) ((arg1)->destination);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_BlendMultiplier->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendEquation_operation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendEquation *arg1 = (BlendEquation *) 0 ;
  BlendOperation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendEquation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendEquation_operation_set" "', argument " "1"" of type '" "BlendEquation *""'"); 
  }
  arg1 = reinterpret_cast< BlendEquation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlendEquation_operation_set" "', argument " "2"" of type '" "BlendOperation""'");
  } 
  arg2 = static_cast< BlendOperation >(val2);
  if (arg1) (arg1)->operation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendEquation_operation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendEquation *arg1 = (BlendEquation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BlendOperation result;
  
  if (!SWIG_Python_UnpackTuple(args,"BlendEquation_operation_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendEquation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendEquation_operation_get" "', argument " "1"" of type '" "BlendEquation *""'"); 
  }
  arg1 = reinterpret_cast< BlendEquation * >(argp1);
  result = (BlendOperation) ((arg1)->operation);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_BlendOperation->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlendEquation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendEquation *arg1 = (BlendEquation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_BlendEquation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendEquation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlendEquation" "', argument " "1"" of type '" "BlendEquation *""'"); 
  }
  arg1 = reinterpret_cast< BlendEquation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_BlendEquation) /* defines _wrap_delete_BlendEquation_destructor_closure */

SWIGINTERN int _wrap_new_ColorBlend__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ColorBlend *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ColorBlend *)new ColorBlend();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ColorBlend, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ColorBlend__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ColorBlend *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ColorBlend,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ColorBlend" "', argument " "1"" of type '" "ColorBlend const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColorBlend" "', argument " "1"" of type '" "ColorBlend const &""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  result = (ColorBlend *)new ColorBlend((ColorBlend const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ColorBlend, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ColorBlend(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ColorBlend",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ColorBlend__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ColorBlend__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ColorBlend'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ColorBlend::ColorBlend()\n"
    "    ColorBlend::ColorBlend(ColorBlend const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ColorBlend___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  ColorBlend *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend___lt__" "', argument " "1"" of type '" "ColorBlend const *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ColorBlend,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColorBlend___lt__" "', argument " "2"" of type '" "ColorBlend const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColorBlend___lt__" "', argument " "2"" of type '" "ColorBlend const &""'"); 
  }
  arg2 = reinterpret_cast< ColorBlend * >(argp2);
  result = (bool)((ColorBlend const *)arg1)->operator <((ColorBlend const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend_colorBlend_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  BlendEquation *arg2 = (BlendEquation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend_colorBlend_set" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_BlendEquation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColorBlend_colorBlend_set" "', argument " "2"" of type '" "BlendEquation *""'"); 
  }
  arg2 = reinterpret_cast< BlendEquation * >(argp2);
  if (arg1) (arg1)->colorBlend = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend_colorBlend_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BlendEquation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ColorBlend_colorBlend_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend_colorBlend_get" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  result = (BlendEquation *)& ((arg1)->colorBlend);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BlendEquation, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend_alphaBlend_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  BlendEquation *arg2 = (BlendEquation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend_alphaBlend_set" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_BlendEquation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColorBlend_alphaBlend_set" "', argument " "2"" of type '" "BlendEquation *""'"); 
  }
  arg2 = reinterpret_cast< BlendEquation * >(argp2);
  if (arg1) (arg1)->alphaBlend = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend_alphaBlend_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BlendEquation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ColorBlend_alphaBlend_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend_alphaBlend_get" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  result = (BlendEquation *)& ((arg1)->alphaBlend);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BlendEquation, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend_logicOperation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  LogicOperation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend_logicOperation_set" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorBlend_logicOperation_set" "', argument " "2"" of type '" "LogicOperation""'");
  } 
  arg2 = static_cast< LogicOperation >(val2);
  if (arg1) (arg1)->logicOperation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend_logicOperation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  LogicOperation result;
  
  if (!SWIG_Python_UnpackTuple(args,"ColorBlend_logicOperation_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend_logicOperation_get" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  result = (LogicOperation) ((arg1)->logicOperation);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_LogicOperation->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend_enabled_set" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorBlend_enabled_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ColorBlend_enabled_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend_enabled_get" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  result = (bool) ((arg1)->enabled);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend_logicOperationEnabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend_logicOperationEnabled_set" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorBlend_logicOperationEnabled_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->logicOperationEnabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend_logicOperationEnabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ColorBlend_logicOperationEnabled_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend_logicOperationEnabled_get" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  result = (bool) ((arg1)->logicOperationEnabled);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend_writeMask_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  byte arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend_writeMask_set" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorBlend_writeMask_set" "', argument " "2"" of type '" "byte""'");
  } 
  arg2 = static_cast< byte >(val2);
  if (arg1) (arg1)->writeMask = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend_writeMask_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  byte result;
  
  if (!SWIG_Python_UnpackTuple(args,"ColorBlend_writeMask_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend_writeMask_get" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  result = (byte) ((arg1)->writeMask);
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend___eq__" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ColorBlend___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColorBlend___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorBlend___ne__" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ColorBlend___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ColorBlend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ColorBlend *arg1 = (ColorBlend *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ColorBlend",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ColorBlend, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColorBlend" "', argument " "1"" of type '" "ColorBlend *""'"); 
  }
  arg1 = reinterpret_cast< ColorBlend * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ColorBlend) /* defines _wrap_delete_ColorBlend_destructor_closure */

SWIGINTERN int _wrap_new_RasterState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RasterState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (RasterState *)new RasterState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RasterState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_RasterState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RasterState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  RasterState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RasterState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RasterState" "', argument " "1"" of type '" "RasterState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RasterState" "', argument " "1"" of type '" "RasterState const &""'"); 
  }
  arg1 = reinterpret_cast< RasterState * >(argp1);
  result = (RasterState *)new RasterState((RasterState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RasterState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_RasterState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_RasterState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RasterState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_RasterState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RasterState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RasterState::RasterState()\n"
    "    RasterState::RasterState(RasterState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_RasterState_frontCCW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterState *arg1 = (RasterState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterState_frontCCW_set" "', argument " "1"" of type '" "RasterState *""'"); 
  }
  arg1 = reinterpret_cast< RasterState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterState_frontCCW_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->frontCCW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterState_frontCCW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterState *arg1 = (RasterState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"RasterState_frontCCW_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterState_frontCCW_get" "', argument " "1"" of type '" "RasterState *""'"); 
  }
  arg1 = reinterpret_cast< RasterState * >(argp1);
  result = (bool) ((arg1)->frontCCW);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterState_fillMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterState *arg1 = (RasterState *) 0 ;
  FillMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterState_fillMode_set" "', argument " "1"" of type '" "RasterState *""'"); 
  }
  arg1 = reinterpret_cast< RasterState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterState_fillMode_set" "', argument " "2"" of type '" "FillMode""'");
  } 
  arg2 = static_cast< FillMode >(val2);
  if (arg1) (arg1)->fillMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterState_fillMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterState *arg1 = (RasterState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FillMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"RasterState_fillMode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterState_fillMode_get" "', argument " "1"" of type '" "RasterState *""'"); 
  }
  arg1 = reinterpret_cast< RasterState * >(argp1);
  result = (FillMode) ((arg1)->fillMode);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_FillMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterState_cullMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterState *arg1 = (RasterState *) 0 ;
  CullMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterState_cullMode_set" "', argument " "1"" of type '" "RasterState *""'"); 
  }
  arg1 = reinterpret_cast< RasterState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterState_cullMode_set" "', argument " "2"" of type '" "CullMode""'");
  } 
  arg2 = static_cast< CullMode >(val2);
  if (arg1) (arg1)->cullMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterState_cullMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterState *arg1 = (RasterState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CullMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"RasterState_cullMode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterState_cullMode_get" "', argument " "1"" of type '" "RasterState *""'"); 
  }
  arg1 = reinterpret_cast< RasterState * >(argp1);
  result = (CullMode) ((arg1)->cullMode);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CullMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RasterState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterState *arg1 = (RasterState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_RasterState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RasterState" "', argument " "1"" of type '" "RasterState *""'"); 
  }
  arg1 = reinterpret_cast< RasterState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_RasterState) /* defines _wrap_delete_RasterState_destructor_closure */

SWIGINTERN int _wrap_new_DepthTestState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  DepthTestState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (DepthTestState *)new DepthTestState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DepthTestState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DepthTestState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DepthTestState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DepthTestState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DepthTestState" "', argument " "1"" of type '" "DepthTestState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DepthTestState" "', argument " "1"" of type '" "DepthTestState const &""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  result = (DepthTestState *)new DepthTestState((DepthTestState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DepthTestState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DepthTestState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DepthTestState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DepthTestState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_DepthTestState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DepthTestState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DepthTestState::DepthTestState()\n"
    "    DepthTestState::DepthTestState(DepthTestState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_DepthTestState_depthEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = (DepthTestState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthTestState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthTestState_depthEnable_set" "', argument " "1"" of type '" "DepthTestState *""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DepthTestState_depthEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthTestState_depthEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = (DepthTestState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"DepthTestState_depthEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthTestState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthTestState_depthEnable_get" "', argument " "1"" of type '" "DepthTestState *""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  result = (bool) ((arg1)->depthEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthTestState_depthFunction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = (DepthTestState *) 0 ;
  CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthTestState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthTestState_depthFunction_set" "', argument " "1"" of type '" "DepthTestState *""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DepthTestState_depthFunction_set" "', argument " "2"" of type '" "CompareFunction""'");
  } 
  arg2 = static_cast< CompareFunction >(val2);
  if (arg1) (arg1)->depthFunction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthTestState_depthFunction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = (DepthTestState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompareFunction result;
  
  if (!SWIG_Python_UnpackTuple(args,"DepthTestState_depthFunction_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthTestState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthTestState_depthFunction_get" "', argument " "1"" of type '" "DepthTestState *""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  result = (CompareFunction) ((arg1)->depthFunction);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CompareFunction->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthTestState_depthWrites_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = (DepthTestState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthTestState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthTestState_depthWrites_set" "', argument " "1"" of type '" "DepthTestState *""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DepthTestState_depthWrites_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthWrites = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthTestState_depthWrites_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = (DepthTestState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"DepthTestState_depthWrites_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthTestState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthTestState_depthWrites_get" "', argument " "1"" of type '" "DepthTestState *""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  result = (bool) ((arg1)->depthWrites);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthTestState_depthBounds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = (DepthTestState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthTestState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthTestState_depthBounds_set" "', argument " "1"" of type '" "DepthTestState *""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DepthTestState_depthBounds_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthBounds = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthTestState_depthBounds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = (DepthTestState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"DepthTestState_depthBounds_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthTestState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthTestState_depthBounds_get" "', argument " "1"" of type '" "DepthTestState *""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  result = (bool) ((arg1)->depthBounds);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthTestState_minDepthBounds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = (DepthTestState *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthTestState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthTestState_minDepthBounds_set" "', argument " "1"" of type '" "DepthTestState *""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DepthTestState_minDepthBounds_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->minDepthBounds = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthTestState_minDepthBounds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = (DepthTestState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args,"DepthTestState_minDepthBounds_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthTestState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthTestState_minDepthBounds_get" "', argument " "1"" of type '" "DepthTestState *""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  result = (double) ((arg1)->minDepthBounds);
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthTestState_maxDepthBounds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = (DepthTestState *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthTestState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthTestState_maxDepthBounds_set" "', argument " "1"" of type '" "DepthTestState *""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DepthTestState_maxDepthBounds_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->maxDepthBounds = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthTestState_maxDepthBounds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = (DepthTestState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args,"DepthTestState_maxDepthBounds_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthTestState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthTestState_maxDepthBounds_get" "', argument " "1"" of type '" "DepthTestState *""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  result = (double) ((arg1)->maxDepthBounds);
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DepthTestState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthTestState *arg1 = (DepthTestState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DepthTestState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthTestState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DepthTestState" "', argument " "1"" of type '" "DepthTestState *""'"); 
  }
  arg1 = reinterpret_cast< DepthTestState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DepthTestState) /* defines _wrap_delete_DepthTestState_destructor_closure */

SWIGINTERN int _wrap_new_StencilFace__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  StencilFace *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (StencilFace *)new StencilFace();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StencilFace, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_StencilFace__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  StencilFace *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_StencilFace,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StencilFace" "', argument " "1"" of type '" "StencilFace const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StencilFace" "', argument " "1"" of type '" "StencilFace const &""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  result = (StencilFace *)new StencilFace((StencilFace const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StencilFace, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_StencilFace(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_StencilFace",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_StencilFace__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_StencilFace__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StencilFace'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    StencilFace::StencilFace()\n"
    "    StencilFace::StencilFace(StencilFace const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_StencilFace_failOperation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  StencilOperation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_failOperation_set" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StencilFace_failOperation_set" "', argument " "2"" of type '" "StencilOperation""'");
  } 
  arg2 = static_cast< StencilOperation >(val2);
  if (arg1) (arg1)->failOperation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StencilFace_failOperation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StencilOperation result;
  
  if (!SWIG_Python_UnpackTuple(args,"StencilFace_failOperation_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_failOperation_get" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  result = (StencilOperation) ((arg1)->failOperation);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_StencilOperation->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StencilFace_depthFailOperation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  StencilOperation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_depthFailOperation_set" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StencilFace_depthFailOperation_set" "', argument " "2"" of type '" "StencilOperation""'");
  } 
  arg2 = static_cast< StencilOperation >(val2);
  if (arg1) (arg1)->depthFailOperation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StencilFace_depthFailOperation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StencilOperation result;
  
  if (!SWIG_Python_UnpackTuple(args,"StencilFace_depthFailOperation_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_depthFailOperation_get" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  result = (StencilOperation) ((arg1)->depthFailOperation);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_StencilOperation->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StencilFace_passOperation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  StencilOperation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_passOperation_set" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StencilFace_passOperation_set" "', argument " "2"" of type '" "StencilOperation""'");
  } 
  arg2 = static_cast< StencilOperation >(val2);
  if (arg1) (arg1)->passOperation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StencilFace_passOperation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StencilOperation result;
  
  if (!SWIG_Python_UnpackTuple(args,"StencilFace_passOperation_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_passOperation_get" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  result = (StencilOperation) ((arg1)->passOperation);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_StencilOperation->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StencilFace_function_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_function_set" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StencilFace_function_set" "', argument " "2"" of type '" "CompareFunction""'");
  } 
  arg2 = static_cast< CompareFunction >(val2);
  if (arg1) (arg1)->function = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StencilFace_function_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompareFunction result;
  
  if (!SWIG_Python_UnpackTuple(args,"StencilFace_function_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_function_get" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  result = (CompareFunction) ((arg1)->function);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CompareFunction->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StencilFace_reference_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_reference_set" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StencilFace_reference_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->reference = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StencilFace_reference_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"StencilFace_reference_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_reference_get" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  result = (uint32_t) ((arg1)->reference);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StencilFace_compareMask_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_compareMask_set" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StencilFace_compareMask_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->compareMask = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StencilFace_compareMask_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"StencilFace_compareMask_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_compareMask_get" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  result = (uint32_t) ((arg1)->compareMask);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StencilFace_writeMask_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_writeMask_set" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StencilFace_writeMask_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->writeMask = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StencilFace_writeMask_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"StencilFace_writeMask_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StencilFace_writeMask_get" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  result = (uint32_t) ((arg1)->writeMask);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StencilFace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilFace *arg1 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_StencilFace",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilFace, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StencilFace" "', argument " "1"" of type '" "StencilFace *""'"); 
  }
  arg1 = reinterpret_cast< StencilFace * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_StencilFace) /* defines _wrap_delete_StencilFace_destructor_closure */

SWIGINTERN int _wrap_new_BoundVBuffer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  BoundVBuffer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (BoundVBuffer *)new BoundVBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BoundVBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_BoundVBuffer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BoundVBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  BoundVBuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_BoundVBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundVBuffer" "', argument " "1"" of type '" "BoundVBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundVBuffer" "', argument " "1"" of type '" "BoundVBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< BoundVBuffer * >(argp1);
  result = (BoundVBuffer *)new BoundVBuffer((BoundVBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BoundVBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_BoundVBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_BoundVBuffer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_BoundVBuffer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_BoundVBuffer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BoundVBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BoundVBuffer::BoundVBuffer()\n"
    "    BoundVBuffer::BoundVBuffer(BoundVBuffer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_BoundVBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoundVBuffer *arg1 = (BoundVBuffer *) 0 ;
  BoundVBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BoundVBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundVBuffer___lt__" "', argument " "1"" of type '" "BoundVBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< BoundVBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_BoundVBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundVBuffer___lt__" "', argument " "2"" of type '" "BoundVBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundVBuffer___lt__" "', argument " "2"" of type '" "BoundVBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< BoundVBuffer * >(argp2);
  result = (bool)((BoundVBuffer const *)arg1)->operator <((BoundVBuffer const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoundVBuffer_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoundVBuffer *arg1 = (BoundVBuffer *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BoundVBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundVBuffer_resourceId_set" "', argument " "1"" of type '" "BoundVBuffer *""'"); 
  }
  arg1 = reinterpret_cast< BoundVBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundVBuffer_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoundVBuffer_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoundVBuffer *arg1 = (BoundVBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"BoundVBuffer_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BoundVBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundVBuffer_resourceId_get" "', argument " "1"" of type '" "BoundVBuffer *""'"); 
  }
  arg1 = reinterpret_cast< BoundVBuffer * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoundVBuffer_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoundVBuffer *arg1 = (BoundVBuffer *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BoundVBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundVBuffer_byteOffset_set" "', argument " "1"" of type '" "BoundVBuffer *""'"); 
  }
  arg1 = reinterpret_cast< BoundVBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoundVBuffer_byteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoundVBuffer_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoundVBuffer *arg1 = (BoundVBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"BoundVBuffer_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BoundVBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundVBuffer_byteOffset_get" "', argument " "1"" of type '" "BoundVBuffer *""'"); 
  }
  arg1 = reinterpret_cast< BoundVBuffer * >(argp1);
  result = (uint64_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoundVBuffer_byteStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoundVBuffer *arg1 = (BoundVBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BoundVBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundVBuffer_byteStride_set" "', argument " "1"" of type '" "BoundVBuffer *""'"); 
  }
  arg1 = reinterpret_cast< BoundVBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoundVBuffer_byteStride_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoundVBuffer_byteStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoundVBuffer *arg1 = (BoundVBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"BoundVBuffer_byteStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BoundVBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundVBuffer_byteStride_get" "', argument " "1"" of type '" "BoundVBuffer *""'"); 
  }
  arg1 = reinterpret_cast< BoundVBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteStride);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoundVBuffer_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoundVBuffer *arg1 = (BoundVBuffer *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BoundVBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundVBuffer_byteSize_set" "', argument " "1"" of type '" "BoundVBuffer *""'"); 
  }
  arg1 = reinterpret_cast< BoundVBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoundVBuffer_byteSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoundVBuffer_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoundVBuffer *arg1 = (BoundVBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"BoundVBuffer_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BoundVBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundVBuffer_byteSize_get" "', argument " "1"" of type '" "BoundVBuffer *""'"); 
  }
  arg1 = reinterpret_cast< BoundVBuffer * >(argp1);
  result = (uint64_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoundVBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoundVBuffer *arg1 = (BoundVBuffer *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BoundVBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundVBuffer___eq__" "', argument " "1"" of type '" "BoundVBuffer *""'"); 
  }
  arg1 = reinterpret_cast< BoundVBuffer * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)BoundVBuffer___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoundVBuffer___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoundVBuffer *arg1 = (BoundVBuffer *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BoundVBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundVBuffer___ne__" "', argument " "1"" of type '" "BoundVBuffer *""'"); 
  }
  arg1 = reinterpret_cast< BoundVBuffer * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)BoundVBuffer___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoundVBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoundVBuffer *arg1 = (BoundVBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_BoundVBuffer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BoundVBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoundVBuffer" "', argument " "1"" of type '" "BoundVBuffer *""'"); 
  }
  arg1 = reinterpret_cast< BoundVBuffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_BoundVBuffer) /* defines _wrap_delete_BoundVBuffer_destructor_closure */

SWIGINTERN int _wrap_new_Descriptor__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Descriptor *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (Descriptor *)new Descriptor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Descriptor, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Descriptor__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Descriptor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Descriptor,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Descriptor" "', argument " "1"" of type '" "Descriptor const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Descriptor" "', argument " "1"" of type '" "Descriptor const &""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (Descriptor *)new Descriptor((Descriptor const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Descriptor, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Descriptor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Descriptor",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Descriptor__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_Descriptor__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Descriptor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Descriptor::Descriptor()\n"
    "    Descriptor::Descriptor(Descriptor const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_Descriptor___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  Descriptor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor___eq__" "', argument " "1"" of type '" "Descriptor const *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_Descriptor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Descriptor___eq__" "', argument " "2"" of type '" "Descriptor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Descriptor___eq__" "', argument " "2"" of type '" "Descriptor const &""'"); 
  }
  arg2 = reinterpret_cast< Descriptor * >(argp2);
  result = (bool)((Descriptor const *)arg1)->operator ==((Descriptor const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  Descriptor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor___lt__" "', argument " "1"" of type '" "Descriptor const *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_Descriptor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Descriptor___lt__" "', argument " "2"" of type '" "Descriptor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Descriptor___lt__" "', argument " "2"" of type '" "Descriptor const &""'"); 
  }
  arg2 = reinterpret_cast< Descriptor * >(argp2);
  result = (bool)((Descriptor const *)arg1)->operator <((Descriptor const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  DescriptorType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_type_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Descriptor_type_set" "', argument " "2"" of type '" "DescriptorType""'");
  } 
  arg2 = static_cast< DescriptorType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DescriptorType result;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_type_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (DescriptorType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_DescriptorType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  DescriptorFlags arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_flags_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Descriptor_flags_set" "', argument " "2"" of type '" "DescriptorFlags""'");
  } 
  arg2 = static_cast< DescriptorFlags >(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DescriptorFlags result;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_flags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_flags_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (DescriptorFlags) ((arg1)->flags);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_DescriptorFlags->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_format_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  ResourceFormat *arg2 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_format_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Descriptor_format_set" "', argument " "2"" of type '" "ResourceFormat *""'"); 
  }
  arg2 = reinterpret_cast< ResourceFormat * >(argp2);
  if (arg1) (arg1)->format = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_format_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceFormat *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_format_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_format_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (ResourceFormat *)& ((arg1)->format);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_resource_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_resource_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Descriptor_resource_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resource = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_resource_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_resource_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_resource_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (ResourceId *)& ((arg1)->resource);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_secondary_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_secondary_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Descriptor_secondary_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->secondary = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_secondary_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_secondary_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_secondary_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (ResourceId *)& ((arg1)->secondary);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_view_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_view_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Descriptor_view_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->view = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_view_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_view_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_view_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (ResourceId *)& ((arg1)->view);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_byteOffset_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Descriptor_byteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_byteOffset_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (uint64_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_byteSize_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Descriptor_byteSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_byteSize_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (uint64_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_counterByteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_counterByteOffset_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Descriptor_counterByteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->counterByteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_counterByteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_counterByteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_counterByteOffset_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (uint32_t) ((arg1)->counterByteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_bufferStructCount_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_bufferStructCount_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Descriptor_bufferStructCount_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->bufferStructCount = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_bufferStructCount_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_bufferStructCount_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_bufferStructCount_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (uint32_t) ((arg1)->bufferStructCount);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_elementByteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_elementByteSize_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Descriptor_elementByteSize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->elementByteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_elementByteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_elementByteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_elementByteSize_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (uint32_t) ((arg1)->elementByteSize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_minLODClamp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_minLODClamp_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Descriptor_minLODClamp_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->minLODClamp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_minLODClamp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_minLODClamp_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_minLODClamp_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (float) ((arg1)->minLODClamp);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_firstSlice_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  uint16_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_firstSlice_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Descriptor_firstSlice_set" "', argument " "2"" of type '" "uint16_t""'");
  } 
  arg2 = static_cast< uint16_t >(val2);
  if (arg1) (arg1)->firstSlice = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_firstSlice_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint16_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_firstSlice_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_firstSlice_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (uint16_t) ((arg1)->firstSlice);
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_numSlices_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  uint16_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_numSlices_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Descriptor_numSlices_set" "', argument " "2"" of type '" "uint16_t""'");
  } 
  arg2 = static_cast< uint16_t >(val2);
  if (arg1) (arg1)->numSlices = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_numSlices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint16_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_numSlices_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_numSlices_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (uint16_t) ((arg1)->numSlices);
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_firstMip_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_firstMip_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Descriptor_firstMip_set" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  if (arg1) (arg1)->firstMip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_firstMip_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_firstMip_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_firstMip_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (uint8_t) ((arg1)->firstMip);
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_numMips_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_numMips_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Descriptor_numMips_set" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  if (arg1) (arg1)->numMips = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_numMips_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_numMips_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_numMips_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (uint8_t) ((arg1)->numMips);
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_swizzle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  TextureSwizzle4 *arg2 = (TextureSwizzle4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_swizzle_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Descriptor_swizzle_set" "', argument " "2"" of type '" "TextureSwizzle4 *""'"); 
  }
  arg2 = reinterpret_cast< TextureSwizzle4 * >(argp2);
  if (arg1) (arg1)->swizzle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_swizzle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureSwizzle4 *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_swizzle_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_swizzle_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (TextureSwizzle4 *)& ((arg1)->swizzle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_textureType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  TextureType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_textureType_set" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Descriptor_textureType_set" "', argument " "2"" of type '" "TextureType""'");
  } 
  arg2 = static_cast< TextureType >(val2);
  if (arg1) (arg1)->textureType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Descriptor_textureType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureType result;
  
  if (!SWIG_Python_UnpackTuple(args,"Descriptor_textureType_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Descriptor_textureType_get" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  result = (TextureType) ((arg1)->textureType);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_TextureType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Descriptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Descriptor *arg1 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_Descriptor",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Descriptor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Descriptor" "', argument " "1"" of type '" "Descriptor *""'"); 
  }
  arg1 = reinterpret_cast< Descriptor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_Descriptor) /* defines _wrap_delete_Descriptor_destructor_closure */

SWIGINTERN int _wrap_new_SamplerDescriptor__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SamplerDescriptor *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SamplerDescriptor *)new SamplerDescriptor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SamplerDescriptor, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_SamplerDescriptor__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SamplerDescriptor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerDescriptor,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SamplerDescriptor" "', argument " "1"" of type '" "SamplerDescriptor const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SamplerDescriptor" "', argument " "1"" of type '" "SamplerDescriptor const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (SamplerDescriptor *)new SamplerDescriptor((SamplerDescriptor const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SamplerDescriptor, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_SamplerDescriptor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SamplerDescriptor",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SamplerDescriptor__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_SamplerDescriptor__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SamplerDescriptor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SamplerDescriptor::SamplerDescriptor()\n"
    "    SamplerDescriptor::SamplerDescriptor(SamplerDescriptor const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  SamplerDescriptor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor___eq__" "', argument " "1"" of type '" "SamplerDescriptor const *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_SamplerDescriptor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SamplerDescriptor___eq__" "', argument " "2"" of type '" "SamplerDescriptor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SamplerDescriptor___eq__" "', argument " "2"" of type '" "SamplerDescriptor const &""'"); 
  }
  arg2 = reinterpret_cast< SamplerDescriptor * >(argp2);
  result = (bool)((SamplerDescriptor const *)arg1)->operator ==((SamplerDescriptor const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  SamplerDescriptor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor___lt__" "', argument " "1"" of type '" "SamplerDescriptor const *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_SamplerDescriptor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SamplerDescriptor___lt__" "', argument " "2"" of type '" "SamplerDescriptor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SamplerDescriptor___lt__" "', argument " "2"" of type '" "SamplerDescriptor const &""'"); 
  }
  arg2 = reinterpret_cast< SamplerDescriptor * >(argp2);
  result = (bool)((SamplerDescriptor const *)arg1)->operator <((SamplerDescriptor const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_object_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_object_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SamplerDescriptor_object_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->object = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_object_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_object_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_object_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (ResourceId *)& ((arg1)->object);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  DescriptorType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_type_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_type_set" "', argument " "2"" of type '" "DescriptorType""'");
  } 
  arg2 = static_cast< DescriptorType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DescriptorType result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_type_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (DescriptorType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_DescriptorType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_addressU_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  AddressMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_addressU_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_addressU_set" "', argument " "2"" of type '" "AddressMode""'");
  } 
  arg2 = static_cast< AddressMode >(val2);
  if (arg1) (arg1)->addressU = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_addressU_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AddressMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_addressU_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_addressU_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (AddressMode) ((arg1)->addressU);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_AddressMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_addressV_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  AddressMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_addressV_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_addressV_set" "', argument " "2"" of type '" "AddressMode""'");
  } 
  arg2 = static_cast< AddressMode >(val2);
  if (arg1) (arg1)->addressV = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_addressV_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AddressMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_addressV_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_addressV_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (AddressMode) ((arg1)->addressV);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_AddressMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_addressW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  AddressMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_addressW_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_addressW_set" "', argument " "2"" of type '" "AddressMode""'");
  } 
  arg2 = static_cast< AddressMode >(val2);
  if (arg1) (arg1)->addressW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_addressW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AddressMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_addressW_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_addressW_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (AddressMode) ((arg1)->addressW);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_AddressMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_compareFunction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_compareFunction_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_compareFunction_set" "', argument " "2"" of type '" "CompareFunction""'");
  } 
  arg2 = static_cast< CompareFunction >(val2);
  if (arg1) (arg1)->compareFunction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_compareFunction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompareFunction result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_compareFunction_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_compareFunction_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (CompareFunction) ((arg1)->compareFunction);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CompareFunction->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_filter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  TextureFilter *arg2 = (TextureFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_filter_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_TextureFilter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SamplerDescriptor_filter_set" "', argument " "2"" of type '" "TextureFilter *""'"); 
  }
  arg2 = reinterpret_cast< TextureFilter * >(argp2);
  if (arg1) (arg1)->filter = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_filter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureFilter *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_filter_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_filter_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (TextureFilter *)& ((arg1)->filter);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureFilter, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_srgbBorder_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_srgbBorder_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_srgbBorder_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->srgbBorder = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_srgbBorder_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_srgbBorder_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_srgbBorder_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (bool) ((arg1)->srgbBorder);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_seamlessCubemaps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_seamlessCubemaps_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_seamlessCubemaps_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->seamlessCubemaps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_seamlessCubemaps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_seamlessCubemaps_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_seamlessCubemaps_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (bool) ((arg1)->seamlessCubemaps);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_unnormalized_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_unnormalized_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_unnormalized_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->unnormalized = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_unnormalized_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_unnormalized_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_unnormalized_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (bool) ((arg1)->unnormalized);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_maxAnisotropy_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_maxAnisotropy_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_maxAnisotropy_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->maxAnisotropy = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_maxAnisotropy_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_maxAnisotropy_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_maxAnisotropy_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (float) ((arg1)->maxAnisotropy);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_maxLOD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_maxLOD_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_maxLOD_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->maxLOD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_maxLOD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_maxLOD_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_maxLOD_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (float) ((arg1)->maxLOD);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_minLOD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_minLOD_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_minLOD_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->minLOD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_minLOD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_minLOD_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_minLOD_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (float) ((arg1)->minLOD);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_mipBias_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_mipBias_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_mipBias_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->mipBias = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_mipBias_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_mipBias_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_mipBias_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (float) ((arg1)->mipBias);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_borderColorValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  PixelValue *arg2 = (PixelValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_borderColorValue_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_PixelValue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SamplerDescriptor_borderColorValue_set" "', argument " "2"" of type '" "PixelValue *""'"); 
  }
  arg2 = reinterpret_cast< PixelValue * >(argp2);
  if (arg1) (arg1)->borderColorValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_borderColorValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PixelValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_borderColorValue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_borderColorValue_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (PixelValue *)& ((arg1)->borderColorValue);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PixelValue, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_borderColorType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  CompType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_borderColorType_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_borderColorType_set" "', argument " "2"" of type '" "CompType""'");
  } 
  arg2 = static_cast< CompType >(val2);
  if (arg1) (arg1)->borderColorType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_borderColorType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompType result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_borderColorType_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_borderColorType_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (CompType) ((arg1)->borderColorType);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CompType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_swizzle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  TextureSwizzle4 *arg2 = (TextureSwizzle4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_swizzle_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SamplerDescriptor_swizzle_set" "', argument " "2"" of type '" "TextureSwizzle4 *""'"); 
  }
  arg2 = reinterpret_cast< TextureSwizzle4 * >(argp2);
  if (arg1) (arg1)->swizzle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_swizzle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureSwizzle4 *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_swizzle_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_swizzle_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (TextureSwizzle4 *)& ((arg1)->swizzle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_ycbcrModel_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  YcbcrConversion arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_ycbcrModel_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_ycbcrModel_set" "', argument " "2"" of type '" "YcbcrConversion""'");
  } 
  arg2 = static_cast< YcbcrConversion >(val2);
  if (arg1) (arg1)->ycbcrModel = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_ycbcrModel_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  YcbcrConversion result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_ycbcrModel_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_ycbcrModel_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (YcbcrConversion) ((arg1)->ycbcrModel);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_YcbcrConversion->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_ycbcrRange_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  YcbcrRange arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_ycbcrRange_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_ycbcrRange_set" "', argument " "2"" of type '" "YcbcrRange""'");
  } 
  arg2 = static_cast< YcbcrRange >(val2);
  if (arg1) (arg1)->ycbcrRange = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_ycbcrRange_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  YcbcrRange result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_ycbcrRange_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_ycbcrRange_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (YcbcrRange) ((arg1)->ycbcrRange);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_YcbcrRange->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_xChromaOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  ChromaSampleLocation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_xChromaOffset_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_xChromaOffset_set" "', argument " "2"" of type '" "ChromaSampleLocation""'");
  } 
  arg2 = static_cast< ChromaSampleLocation >(val2);
  if (arg1) (arg1)->xChromaOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_xChromaOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ChromaSampleLocation result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_xChromaOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_xChromaOffset_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (ChromaSampleLocation) ((arg1)->xChromaOffset);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ChromaSampleLocation->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_yChromaOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  ChromaSampleLocation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_yChromaOffset_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_yChromaOffset_set" "', argument " "2"" of type '" "ChromaSampleLocation""'");
  } 
  arg2 = static_cast< ChromaSampleLocation >(val2);
  if (arg1) (arg1)->yChromaOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_yChromaOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ChromaSampleLocation result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_yChromaOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_yChromaOffset_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (ChromaSampleLocation) ((arg1)->yChromaOffset);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ChromaSampleLocation->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_chromaFilter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  FilterMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_chromaFilter_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_chromaFilter_set" "', argument " "2"" of type '" "FilterMode""'");
  } 
  arg2 = static_cast< FilterMode >(val2);
  if (arg1) (arg1)->chromaFilter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_chromaFilter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FilterMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_chromaFilter_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_chromaFilter_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (FilterMode) ((arg1)->chromaFilter);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_FilterMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_forceExplicitReconstruction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_forceExplicitReconstruction_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_forceExplicitReconstruction_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->forceExplicitReconstruction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_forceExplicitReconstruction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_forceExplicitReconstruction_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_forceExplicitReconstruction_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (bool) ((arg1)->forceExplicitReconstruction);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_creationTimeConstant_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_creationTimeConstant_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerDescriptor_creationTimeConstant_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->creationTimeConstant = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_creationTimeConstant_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_creationTimeConstant_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_creationTimeConstant_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (bool) ((arg1)->creationTimeConstant);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_ycbcrSampler_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_ycbcrSampler_set" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SamplerDescriptor_ycbcrSampler_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->ycbcrSampler = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_ycbcrSampler_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_ycbcrSampler_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_ycbcrSampler_get" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (ResourceId *)& ((arg1)->ycbcrSampler);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerDescriptor_UseBorder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerDescriptor_UseBorder",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerDescriptor_UseBorder" "', argument " "1"" of type '" "SamplerDescriptor const *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  result = (bool)((SamplerDescriptor const *)arg1)->UseBorder();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SamplerDescriptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerDescriptor *arg1 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_SamplerDescriptor",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerDescriptor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SamplerDescriptor" "', argument " "1"" of type '" "SamplerDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< SamplerDescriptor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_SamplerDescriptor) /* defines _wrap_delete_SamplerDescriptor_destructor_closure */

SWIGINTERN int _wrap_new_DescriptorAccess__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  DescriptorAccess *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (DescriptorAccess *)new DescriptorAccess();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DescriptorAccess, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DescriptorAccess__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DescriptorAccess *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DescriptorAccess,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DescriptorAccess" "', argument " "1"" of type '" "DescriptorAccess const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DescriptorAccess" "', argument " "1"" of type '" "DescriptorAccess const &""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  result = (DescriptorAccess *)new DescriptorAccess((DescriptorAccess const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DescriptorAccess, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DescriptorAccess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DescriptorAccess",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DescriptorAccess__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_DescriptorAccess__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DescriptorAccess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DescriptorAccess::DescriptorAccess()\n"
    "    DescriptorAccess::DescriptorAccess(DescriptorAccess const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess___eq____SWIG_0(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  ShaderBindIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess___eq__" "', argument " "1"" of type '" "DescriptorAccess const *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ShaderBindIndex,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DescriptorAccess___eq__" "', argument " "2"" of type '" "ShaderBindIndex const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DescriptorAccess___eq__" "', argument " "2"" of type '" "ShaderBindIndex const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderBindIndex * >(argp2);
  result = (bool)((DescriptorAccess const *)arg1)->operator ==((ShaderBindIndex const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess___eq____SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  ShaderDirectAccess *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess___eq__" "', argument " "1"" of type '" "DescriptorAccess const *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ShaderDirectAccess,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DescriptorAccess___eq__" "', argument " "2"" of type '" "ShaderDirectAccess const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DescriptorAccess___eq__" "', argument " "2"" of type '" "ShaderDirectAccess const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderDirectAccess * >(argp2);
  result = (bool)((DescriptorAccess const *)arg1)->operator ==((ShaderDirectAccess const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess___eq____SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  DescriptorAccess *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess___eq__" "', argument " "1"" of type '" "DescriptorAccess const *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DescriptorAccess,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DescriptorAccess___eq__" "', argument " "2"" of type '" "DescriptorAccess const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DescriptorAccess___eq__" "', argument " "2"" of type '" "DescriptorAccess const &""'"); 
  }
  arg2 = reinterpret_cast< DescriptorAccess * >(argp2);
  result = (bool)((DescriptorAccess const *)arg1)->operator ==((DescriptorAccess const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess___eq__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"DescriptorAccess___eq__",0,2,argv+1))) SWIG_fail;
  argv[0] = self;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ShaderBindIndex, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_DescriptorAccess___eq____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ShaderDirectAccess, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_DescriptorAccess___eq____SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    return _wrap_DescriptorAccess___eq____SWIG_2(self, argc, argv);
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  DescriptorAccess *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess___lt__" "', argument " "1"" of type '" "DescriptorAccess const *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_DescriptorAccess,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DescriptorAccess___lt__" "', argument " "2"" of type '" "DescriptorAccess const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DescriptorAccess___lt__" "', argument " "2"" of type '" "DescriptorAccess const &""'"); 
  }
  arg2 = reinterpret_cast< DescriptorAccess * >(argp2);
  result = (bool)((DescriptorAccess const *)arg1)->operator <((DescriptorAccess const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_stage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_stage_set" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorAccess_stage_set" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  if (arg1) (arg1)->stage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_stage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStage result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorAccess_stage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_stage_get" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  result = (ShaderStage) ((arg1)->stage);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  DescriptorType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_type_set" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorAccess_type_set" "', argument " "2"" of type '" "DescriptorType""'");
  } 
  arg2 = static_cast< DescriptorType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DescriptorType result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorAccess_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_type_get" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  result = (DescriptorType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_DescriptorType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  uint16_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_index_set" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorAccess_index_set" "', argument " "2"" of type '" "uint16_t""'");
  } 
  arg2 = static_cast< uint16_t >(val2);
  if (arg1) (arg1)->index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint16_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorAccess_index_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_index_get" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  result = (uint16_t) ((arg1)->index);
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_arrayElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_arrayElement_set" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorAccess_arrayElement_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->arrayElement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_arrayElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorAccess_arrayElement_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_arrayElement_get" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  result = (uint32_t) ((arg1)->arrayElement);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_descriptorStore_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_descriptorStore_set" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DescriptorAccess_descriptorStore_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->descriptorStore = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_descriptorStore_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorAccess_descriptorStore_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_descriptorStore_get" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  result = (ResourceId *)& ((arg1)->descriptorStore);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_byteOffset_set" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorAccess_byteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorAccess_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_byteOffset_get" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  result = (uint32_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_byteSize_set" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorAccess_byteSize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorAccess_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_byteSize_get" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  result = (uint32_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_staticallyUnused_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_staticallyUnused_set" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorAccess_staticallyUnused_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->staticallyUnused = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorAccess_staticallyUnused_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorAccess_staticallyUnused_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorAccess_staticallyUnused_get" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  result = (bool) ((arg1)->staticallyUnused);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DescriptorAccess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = (DescriptorAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DescriptorAccess",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorAccess, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DescriptorAccess" "', argument " "1"" of type '" "DescriptorAccess *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DescriptorAccess) /* defines _wrap_delete_DescriptorAccess_destructor_closure */

SWIGINTERN int _wrap_new_DescriptorLogicalLocation__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  DescriptorLogicalLocation *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (DescriptorLogicalLocation *)new DescriptorLogicalLocation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DescriptorLogicalLocation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DescriptorLogicalLocation__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DescriptorLogicalLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DescriptorLogicalLocation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DescriptorLogicalLocation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DescriptorLogicalLocation" "', argument " "1"" of type '" "DescriptorLogicalLocation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DescriptorLogicalLocation" "', argument " "1"" of type '" "DescriptorLogicalLocation const &""'"); 
  }
  arg1 = reinterpret_cast< DescriptorLogicalLocation * >(argp1);
  result = (DescriptorLogicalLocation *)new DescriptorLogicalLocation((DescriptorLogicalLocation const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DescriptorLogicalLocation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DescriptorLogicalLocation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DescriptorLogicalLocation",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DescriptorLogicalLocation__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_DescriptorLogicalLocation__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DescriptorLogicalLocation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DescriptorLogicalLocation::DescriptorLogicalLocation()\n"
    "    DescriptorLogicalLocation::DescriptorLogicalLocation(DescriptorLogicalLocation const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_DescriptorLogicalLocation___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorLogicalLocation *arg1 = (DescriptorLogicalLocation *) 0 ;
  DescriptorLogicalLocation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorLogicalLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorLogicalLocation___eq__" "', argument " "1"" of type '" "DescriptorLogicalLocation const *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorLogicalLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_DescriptorLogicalLocation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DescriptorLogicalLocation___eq__" "', argument " "2"" of type '" "DescriptorLogicalLocation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DescriptorLogicalLocation___eq__" "', argument " "2"" of type '" "DescriptorLogicalLocation const &""'"); 
  }
  arg2 = reinterpret_cast< DescriptorLogicalLocation * >(argp2);
  result = (bool)((DescriptorLogicalLocation const *)arg1)->operator ==((DescriptorLogicalLocation const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorLogicalLocation___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorLogicalLocation *arg1 = (DescriptorLogicalLocation *) 0 ;
  DescriptorLogicalLocation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorLogicalLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorLogicalLocation___lt__" "', argument " "1"" of type '" "DescriptorLogicalLocation const *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorLogicalLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_DescriptorLogicalLocation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DescriptorLogicalLocation___lt__" "', argument " "2"" of type '" "DescriptorLogicalLocation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DescriptorLogicalLocation___lt__" "', argument " "2"" of type '" "DescriptorLogicalLocation const &""'"); 
  }
  arg2 = reinterpret_cast< DescriptorLogicalLocation * >(argp2);
  result = (bool)((DescriptorLogicalLocation const *)arg1)->operator <((DescriptorLogicalLocation const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorLogicalLocation_stageMask_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorLogicalLocation *arg1 = (DescriptorLogicalLocation *) 0 ;
  ShaderStageMask arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorLogicalLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorLogicalLocation_stageMask_set" "', argument " "1"" of type '" "DescriptorLogicalLocation *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorLogicalLocation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorLogicalLocation_stageMask_set" "', argument " "2"" of type '" "ShaderStageMask""'");
  } 
  arg2 = static_cast< ShaderStageMask >(val2);
  if (arg1) (arg1)->stageMask = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorLogicalLocation_stageMask_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorLogicalLocation *arg1 = (DescriptorLogicalLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStageMask result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorLogicalLocation_stageMask_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorLogicalLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorLogicalLocation_stageMask_get" "', argument " "1"" of type '" "DescriptorLogicalLocation *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorLogicalLocation * >(argp1);
  result = (ShaderStageMask) ((arg1)->stageMask);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStageMask->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorLogicalLocation_category_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorLogicalLocation *arg1 = (DescriptorLogicalLocation *) 0 ;
  DescriptorCategory arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorLogicalLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorLogicalLocation_category_set" "', argument " "1"" of type '" "DescriptorLogicalLocation *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorLogicalLocation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorLogicalLocation_category_set" "', argument " "2"" of type '" "DescriptorCategory""'");
  } 
  arg2 = static_cast< DescriptorCategory >(val2);
  if (arg1) (arg1)->category = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorLogicalLocation_category_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorLogicalLocation *arg1 = (DescriptorLogicalLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DescriptorCategory result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorLogicalLocation_category_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorLogicalLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorLogicalLocation_category_get" "', argument " "1"" of type '" "DescriptorLogicalLocation *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorLogicalLocation * >(argp1);
  result = (DescriptorCategory) ((arg1)->category);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_DescriptorCategory->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorLogicalLocation_fixedBindNumber_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorLogicalLocation *arg1 = (DescriptorLogicalLocation *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorLogicalLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorLogicalLocation_fixedBindNumber_set" "', argument " "1"" of type '" "DescriptorLogicalLocation *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorLogicalLocation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorLogicalLocation_fixedBindNumber_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->fixedBindNumber = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorLogicalLocation_fixedBindNumber_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorLogicalLocation *arg1 = (DescriptorLogicalLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorLogicalLocation_fixedBindNumber_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorLogicalLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorLogicalLocation_fixedBindNumber_get" "', argument " "1"" of type '" "DescriptorLogicalLocation *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorLogicalLocation * >(argp1);
  result = (uint32_t) ((arg1)->fixedBindNumber);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorLogicalLocation_logicalBindName_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorLogicalLocation *arg1 = (DescriptorLogicalLocation *) 0 ;
  rdcinflexiblestr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcinflexiblestr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorLogicalLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorLogicalLocation_logicalBindName_set" "', argument " "1"" of type '" "DescriptorLogicalLocation *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorLogicalLocation * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'DescriptorLogicalLocation_logicalBindName_set' argument 2 of type 'rdcinflexiblestr'"); 
    }
  }
  if (arg1) (arg1)->logicalBindName = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorLogicalLocation_logicalBindName_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorLogicalLocation *arg1 = (DescriptorLogicalLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcinflexiblestr result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorLogicalLocation_logicalBindName_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorLogicalLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorLogicalLocation_logicalBindName_get" "', argument " "1"" of type '" "DescriptorLogicalLocation *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorLogicalLocation * >(argp1);
  result =  ((arg1)->logicalBindName);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DescriptorLogicalLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorLogicalLocation *arg1 = (DescriptorLogicalLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DescriptorLogicalLocation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorLogicalLocation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DescriptorLogicalLocation" "', argument " "1"" of type '" "DescriptorLogicalLocation *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorLogicalLocation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DescriptorLogicalLocation) /* defines _wrap_delete_DescriptorLogicalLocation_destructor_closure */

SWIGINTERN int _wrap_new_UsedDescriptor__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  UsedDescriptor *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (UsedDescriptor *)new UsedDescriptor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UsedDescriptor, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_UsedDescriptor__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UsedDescriptor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UsedDescriptor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_UsedDescriptor,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UsedDescriptor" "', argument " "1"" of type '" "UsedDescriptor const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UsedDescriptor" "', argument " "1"" of type '" "UsedDescriptor const &""'"); 
  }
  arg1 = reinterpret_cast< UsedDescriptor * >(argp1);
  result = (UsedDescriptor *)new UsedDescriptor((UsedDescriptor const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UsedDescriptor, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_UsedDescriptor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_UsedDescriptor",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UsedDescriptor__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_UsedDescriptor__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UsedDescriptor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UsedDescriptor::UsedDescriptor()\n"
    "    UsedDescriptor::UsedDescriptor(UsedDescriptor const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_UsedDescriptor___eq____SWIG_0(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UsedDescriptor *arg1 = (UsedDescriptor *) 0 ;
  DescriptorAccess *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_UsedDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsedDescriptor___eq__" "', argument " "1"" of type '" "UsedDescriptor const *""'"); 
  }
  arg1 = reinterpret_cast< UsedDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DescriptorAccess,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UsedDescriptor___eq__" "', argument " "2"" of type '" "DescriptorAccess const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UsedDescriptor___eq__" "', argument " "2"" of type '" "DescriptorAccess const &""'"); 
  }
  arg2 = reinterpret_cast< DescriptorAccess * >(argp2);
  result = (bool)((UsedDescriptor const *)arg1)->operator ==((DescriptorAccess const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UsedDescriptor___eq____SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UsedDescriptor *arg1 = (UsedDescriptor *) 0 ;
  ShaderBindIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_UsedDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsedDescriptor___eq__" "', argument " "1"" of type '" "UsedDescriptor const *""'"); 
  }
  arg1 = reinterpret_cast< UsedDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ShaderBindIndex,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UsedDescriptor___eq__" "', argument " "2"" of type '" "ShaderBindIndex const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UsedDescriptor___eq__" "', argument " "2"" of type '" "ShaderBindIndex const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderBindIndex * >(argp2);
  result = (bool)((UsedDescriptor const *)arg1)->operator ==((ShaderBindIndex const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UsedDescriptor___eq____SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UsedDescriptor *arg1 = (UsedDescriptor *) 0 ;
  ShaderDirectAccess *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_UsedDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsedDescriptor___eq__" "', argument " "1"" of type '" "UsedDescriptor const *""'"); 
  }
  arg1 = reinterpret_cast< UsedDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ShaderDirectAccess,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UsedDescriptor___eq__" "', argument " "2"" of type '" "ShaderDirectAccess const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UsedDescriptor___eq__" "', argument " "2"" of type '" "ShaderDirectAccess const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderDirectAccess * >(argp2);
  result = (bool)((UsedDescriptor const *)arg1)->operator ==((ShaderDirectAccess const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UsedDescriptor___eq____SWIG_3(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UsedDescriptor *arg1 = (UsedDescriptor *) 0 ;
  UsedDescriptor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_UsedDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsedDescriptor___eq__" "', argument " "1"" of type '" "UsedDescriptor const *""'"); 
  }
  arg1 = reinterpret_cast< UsedDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_UsedDescriptor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UsedDescriptor___eq__" "', argument " "2"" of type '" "UsedDescriptor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UsedDescriptor___eq__" "', argument " "2"" of type '" "UsedDescriptor const &""'"); 
  }
  arg2 = reinterpret_cast< UsedDescriptor * >(argp2);
  result = (bool)((UsedDescriptor const *)arg1)->operator ==((UsedDescriptor const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UsedDescriptor___eq__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"UsedDescriptor___eq__",0,2,argv+1))) SWIG_fail;
  argv[0] = self;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_DescriptorAccess, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_UsedDescriptor___eq____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ShaderBindIndex, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_UsedDescriptor___eq____SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ShaderDirectAccess, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_UsedDescriptor___eq____SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    return _wrap_UsedDescriptor___eq____SWIG_3(self, argc, argv);
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_UsedDescriptor___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UsedDescriptor *arg1 = (UsedDescriptor *) 0 ;
  UsedDescriptor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_UsedDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsedDescriptor___lt__" "', argument " "1"" of type '" "UsedDescriptor const *""'"); 
  }
  arg1 = reinterpret_cast< UsedDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_UsedDescriptor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UsedDescriptor___lt__" "', argument " "2"" of type '" "UsedDescriptor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UsedDescriptor___lt__" "', argument " "2"" of type '" "UsedDescriptor const &""'"); 
  }
  arg2 = reinterpret_cast< UsedDescriptor * >(argp2);
  result = (bool)((UsedDescriptor const *)arg1)->operator <((UsedDescriptor const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UsedDescriptor_access_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UsedDescriptor *arg1 = (UsedDescriptor *) 0 ;
  DescriptorAccess *arg2 = (DescriptorAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_UsedDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsedDescriptor_access_set" "', argument " "1"" of type '" "UsedDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< UsedDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UsedDescriptor_access_set" "', argument " "2"" of type '" "DescriptorAccess *""'"); 
  }
  arg2 = reinterpret_cast< DescriptorAccess * >(argp2);
  if (arg1) (arg1)->access = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UsedDescriptor_access_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UsedDescriptor *arg1 = (UsedDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DescriptorAccess *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"UsedDescriptor_access_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_UsedDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsedDescriptor_access_get" "', argument " "1"" of type '" "UsedDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< UsedDescriptor * >(argp1);
  result = (DescriptorAccess *)& ((arg1)->access);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DescriptorAccess, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UsedDescriptor_descriptor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UsedDescriptor *arg1 = (UsedDescriptor *) 0 ;
  Descriptor *arg2 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_UsedDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsedDescriptor_descriptor_set" "', argument " "1"" of type '" "UsedDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< UsedDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UsedDescriptor_descriptor_set" "', argument " "2"" of type '" "Descriptor *""'"); 
  }
  arg2 = reinterpret_cast< Descriptor * >(argp2);
  if (arg1) (arg1)->descriptor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UsedDescriptor_descriptor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UsedDescriptor *arg1 = (UsedDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Descriptor *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"UsedDescriptor_descriptor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_UsedDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsedDescriptor_descriptor_get" "', argument " "1"" of type '" "UsedDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< UsedDescriptor * >(argp1);
  result = (Descriptor *)& ((arg1)->descriptor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Descriptor, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UsedDescriptor_sampler_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UsedDescriptor *arg1 = (UsedDescriptor *) 0 ;
  SamplerDescriptor *arg2 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_UsedDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsedDescriptor_sampler_set" "', argument " "1"" of type '" "UsedDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< UsedDescriptor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UsedDescriptor_sampler_set" "', argument " "2"" of type '" "SamplerDescriptor *""'"); 
  }
  arg2 = reinterpret_cast< SamplerDescriptor * >(argp2);
  if (arg1) (arg1)->sampler = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UsedDescriptor_sampler_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UsedDescriptor *arg1 = (UsedDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SamplerDescriptor *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"UsedDescriptor_sampler_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_UsedDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsedDescriptor_sampler_get" "', argument " "1"" of type '" "UsedDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< UsedDescriptor * >(argp1);
  result = (SamplerDescriptor *)& ((arg1)->sampler);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UsedDescriptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UsedDescriptor *arg1 = (UsedDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_UsedDescriptor",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_UsedDescriptor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UsedDescriptor" "', argument " "1"" of type '" "UsedDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< UsedDescriptor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_UsedDescriptor) /* defines _wrap_delete_UsedDescriptor_destructor_closure */

SWIGINTERN int _wrap_new_Offset__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Offset *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (Offset *)new Offset();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Offset, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Offset__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Offset *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Offset *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Offset,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Offset" "', argument " "1"" of type '" "Offset const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Offset" "', argument " "1"" of type '" "Offset const &""'"); 
  }
  arg1 = reinterpret_cast< Offset * >(argp1);
  result = (Offset *)new Offset((Offset const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Offset, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Offset__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int32_t arg1 ;
  int32_t arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Offset *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Offset" "', argument " "1"" of type '" "int32_t""'");
  } 
  arg1 = static_cast< int32_t >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Offset" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  result = (Offset *)new Offset(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Offset, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Offset(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Offset",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Offset__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_Offset__SWIG_1(self, argc, argv);
  }
  if (argc == 2) {
    return _wrap_new_Offset__SWIG_2(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Offset'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Offset::Offset()\n"
    "    Offset::Offset(Offset const &)\n"
    "    Offset::Offset(int32_t,int32_t)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_Offset___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Offset *arg1 = (Offset *) 0 ;
  Offset *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Offset___eq__" "', argument " "1"" of type '" "Offset const *""'"); 
  }
  arg1 = reinterpret_cast< Offset * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_Offset,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Offset___eq__" "', argument " "2"" of type '" "Offset const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Offset___eq__" "', argument " "2"" of type '" "Offset const &""'"); 
  }
  arg2 = reinterpret_cast< Offset * >(argp2);
  result = (bool)((Offset const *)arg1)->operator ==((Offset const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Offset___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Offset *arg1 = (Offset *) 0 ;
  Offset *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Offset___lt__" "', argument " "1"" of type '" "Offset const *""'"); 
  }
  arg1 = reinterpret_cast< Offset * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_Offset,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Offset___lt__" "', argument " "2"" of type '" "Offset const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Offset___lt__" "', argument " "2"" of type '" "Offset const &""'"); 
  }
  arg2 = reinterpret_cast< Offset * >(argp2);
  result = (bool)((Offset const *)arg1)->operator <((Offset const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Offset_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Offset *arg1 = (Offset *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Offset_x_set" "', argument " "1"" of type '" "Offset *""'"); 
  }
  arg1 = reinterpret_cast< Offset * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Offset_x_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Offset_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Offset *arg1 = (Offset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Offset_x_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Offset_x_get" "', argument " "1"" of type '" "Offset *""'"); 
  }
  arg1 = reinterpret_cast< Offset * >(argp1);
  result = (int32_t) ((arg1)->x);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Offset_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Offset *arg1 = (Offset *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Offset_y_set" "', argument " "1"" of type '" "Offset *""'"); 
  }
  arg1 = reinterpret_cast< Offset * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Offset_y_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Offset_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Offset *arg1 = (Offset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Offset_y_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Offset_y_get" "', argument " "1"" of type '" "Offset *""'"); 
  }
  arg1 = reinterpret_cast< Offset * >(argp1);
  result = (int32_t) ((arg1)->y);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Offset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Offset *arg1 = (Offset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_Offset",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Offset, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Offset" "', argument " "1"" of type '" "Offset *""'"); 
  }
  arg1 = reinterpret_cast< Offset * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_Offset) /* defines _wrap_delete_Offset_destructor_closure */

SWIGINTERN int _wrap_new_VertexInputAttribute__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VertexInputAttribute *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VertexInputAttribute *)new VertexInputAttribute();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VertexInputAttribute, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VertexInputAttribute__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VertexInputAttribute *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VertexInputAttribute,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VertexInputAttribute" "', argument " "1"" of type '" "VertexInputAttribute const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VertexInputAttribute" "', argument " "1"" of type '" "VertexInputAttribute const &""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  result = (VertexInputAttribute *)new VertexInputAttribute((VertexInputAttribute const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VertexInputAttribute, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VertexInputAttribute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VertexInputAttribute",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VertexInputAttribute__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VertexInputAttribute__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VertexInputAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VertexInputAttribute::VertexInputAttribute()\n"
    "    VertexInputAttribute::VertexInputAttribute(VertexInputAttribute const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  VertexInputAttribute *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute___lt__" "', argument " "1"" of type '" "VertexInputAttribute const *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VertexInputAttribute,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VertexInputAttribute___lt__" "', argument " "2"" of type '" "VertexInputAttribute const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VertexInputAttribute___lt__" "', argument " "2"" of type '" "VertexInputAttribute const &""'"); 
  }
  arg2 = reinterpret_cast< VertexInputAttribute * >(argp2);
  result = (bool)((VertexInputAttribute const *)arg1)->operator <((VertexInputAttribute const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_name_set" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'VertexInputAttribute_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexInputAttribute_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_name_get" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_vertexBuffer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_vertexBuffer_set" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VertexInputAttribute_vertexBuffer_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->vertexBuffer = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_vertexBuffer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexInputAttribute_vertexBuffer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_vertexBuffer_get" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  result = (int) ((arg1)->vertexBuffer);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_byteOffset_set" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VertexInputAttribute_byteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexInputAttribute_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_byteOffset_get" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  result = (uint32_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_perInstance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_perInstance_set" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VertexInputAttribute_perInstance_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->perInstance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_perInstance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexInputAttribute_perInstance_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_perInstance_get" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  result = (bool) ((arg1)->perInstance);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_instanceRate_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_instanceRate_set" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VertexInputAttribute_instanceRate_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->instanceRate = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_instanceRate_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexInputAttribute_instanceRate_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_instanceRate_get" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  result = (int) ((arg1)->instanceRate);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_format_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  ResourceFormat *arg2 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_format_set" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VertexInputAttribute_format_set" "', argument " "2"" of type '" "ResourceFormat *""'"); 
  }
  arg2 = reinterpret_cast< ResourceFormat * >(argp2);
  if (arg1) (arg1)->format = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_format_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceFormat *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexInputAttribute_format_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_format_get" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  result = (ResourceFormat *)& ((arg1)->format);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_genericValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  PixelValue *arg2 = (PixelValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_genericValue_set" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_PixelValue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VertexInputAttribute_genericValue_set" "', argument " "2"" of type '" "PixelValue *""'"); 
  }
  arg2 = reinterpret_cast< PixelValue * >(argp2);
  if (arg1) (arg1)->genericValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_genericValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PixelValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexInputAttribute_genericValue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_genericValue_get" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  result = (PixelValue *)& ((arg1)->genericValue);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PixelValue, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_genericEnabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_genericEnabled_set" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VertexInputAttribute_genericEnabled_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->genericEnabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_genericEnabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexInputAttribute_genericEnabled_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_genericEnabled_get" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  result = (bool) ((arg1)->genericEnabled);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_floatCastWrong_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_floatCastWrong_set" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VertexInputAttribute_floatCastWrong_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->floatCastWrong = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_floatCastWrong_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexInputAttribute_floatCastWrong_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_floatCastWrong_get" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  result = (bool) ((arg1)->floatCastWrong);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_used_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_used_set" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VertexInputAttribute_used_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->used = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute_used_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexInputAttribute_used_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute_used_get" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  result = (bool) ((arg1)->used);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute___eq__" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)VertexInputAttribute___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexInputAttribute___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexInputAttribute___ne__" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)VertexInputAttribute___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VertexInputAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexInputAttribute *arg1 = (VertexInputAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VertexInputAttribute",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexInputAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VertexInputAttribute" "', argument " "1"" of type '" "VertexInputAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VertexInputAttribute * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VertexInputAttribute) /* defines _wrap_delete_VertexInputAttribute_destructor_closure */

SWIGINTERN int _wrap_new_ShaderMeshMessageLocation__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderMeshMessageLocation *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderMeshMessageLocation *)new ShaderMeshMessageLocation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderMeshMessageLocation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderMeshMessageLocation__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderMeshMessageLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderMeshMessageLocation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderMeshMessageLocation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderMeshMessageLocation" "', argument " "1"" of type '" "ShaderMeshMessageLocation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderMeshMessageLocation" "', argument " "1"" of type '" "ShaderMeshMessageLocation const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderMeshMessageLocation * >(argp1);
  result = (ShaderMeshMessageLocation *)new ShaderMeshMessageLocation((ShaderMeshMessageLocation const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderMeshMessageLocation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderMeshMessageLocation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderMeshMessageLocation",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderMeshMessageLocation__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderMeshMessageLocation__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderMeshMessageLocation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderMeshMessageLocation::ShaderMeshMessageLocation()\n"
    "    ShaderMeshMessageLocation::ShaderMeshMessageLocation(ShaderMeshMessageLocation const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderMeshMessageLocation___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMeshMessageLocation *arg1 = (ShaderMeshMessageLocation *) 0 ;
  ShaderMeshMessageLocation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMeshMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMeshMessageLocation___eq__" "', argument " "1"" of type '" "ShaderMeshMessageLocation const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMeshMessageLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderMeshMessageLocation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderMeshMessageLocation___eq__" "', argument " "2"" of type '" "ShaderMeshMessageLocation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderMeshMessageLocation___eq__" "', argument " "2"" of type '" "ShaderMeshMessageLocation const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderMeshMessageLocation * >(argp2);
  result = (bool)((ShaderMeshMessageLocation const *)arg1)->operator ==((ShaderMeshMessageLocation const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMeshMessageLocation___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMeshMessageLocation *arg1 = (ShaderMeshMessageLocation *) 0 ;
  ShaderMeshMessageLocation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMeshMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMeshMessageLocation___lt__" "', argument " "1"" of type '" "ShaderMeshMessageLocation const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMeshMessageLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderMeshMessageLocation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderMeshMessageLocation___lt__" "', argument " "2"" of type '" "ShaderMeshMessageLocation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderMeshMessageLocation___lt__" "', argument " "2"" of type '" "ShaderMeshMessageLocation const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderMeshMessageLocation * >(argp2);
  result = (bool)((ShaderMeshMessageLocation const *)arg1)->operator <((ShaderMeshMessageLocation const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMeshMessageLocation_taskGroup_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMeshMessageLocation *arg1 = (ShaderMeshMessageLocation *) 0 ;
  rdcfixedarray< uint32_t,3 > *arg2 = (rdcfixedarray< uint32_t,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMeshMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMeshMessageLocation_taskGroup_set" "', argument " "1"" of type '" "ShaderMeshMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMeshMessageLocation * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderMeshMessageLocation_taskGroup_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderMeshMessageLocation_taskGroup_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->taskGroup = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMeshMessageLocation_taskGroup_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMeshMessageLocation *arg1 = (ShaderMeshMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint32_t,3 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderMeshMessageLocation_taskGroup_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMeshMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMeshMessageLocation_taskGroup_get" "', argument " "1"" of type '" "ShaderMeshMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMeshMessageLocation * >(argp1);
  result = (rdcfixedarray< uint32_t,3 > *)& ((arg1)->taskGroup);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMeshMessageLocation_meshGroup_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMeshMessageLocation *arg1 = (ShaderMeshMessageLocation *) 0 ;
  rdcfixedarray< uint32_t,3 > *arg2 = (rdcfixedarray< uint32_t,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMeshMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMeshMessageLocation_meshGroup_set" "', argument " "1"" of type '" "ShaderMeshMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMeshMessageLocation * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderMeshMessageLocation_meshGroup_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderMeshMessageLocation_meshGroup_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->meshGroup = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMeshMessageLocation_meshGroup_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMeshMessageLocation *arg1 = (ShaderMeshMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint32_t,3 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderMeshMessageLocation_meshGroup_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMeshMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMeshMessageLocation_meshGroup_get" "', argument " "1"" of type '" "ShaderMeshMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMeshMessageLocation * >(argp1);
  result = (rdcfixedarray< uint32_t,3 > *)& ((arg1)->meshGroup);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMeshMessageLocation_thread_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMeshMessageLocation *arg1 = (ShaderMeshMessageLocation *) 0 ;
  rdcfixedarray< uint32_t,3 > *arg2 = (rdcfixedarray< uint32_t,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMeshMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMeshMessageLocation_thread_set" "', argument " "1"" of type '" "ShaderMeshMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMeshMessageLocation * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderMeshMessageLocation_thread_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderMeshMessageLocation_thread_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->thread = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMeshMessageLocation_thread_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMeshMessageLocation *arg1 = (ShaderMeshMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint32_t,3 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderMeshMessageLocation_thread_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMeshMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMeshMessageLocation_thread_get" "', argument " "1"" of type '" "ShaderMeshMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMeshMessageLocation * >(argp1);
  result = (rdcfixedarray< uint32_t,3 > *)& ((arg1)->thread);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderMeshMessageLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMeshMessageLocation *arg1 = (ShaderMeshMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderMeshMessageLocation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMeshMessageLocation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderMeshMessageLocation" "', argument " "1"" of type '" "ShaderMeshMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMeshMessageLocation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderMeshMessageLocation) /* defines _wrap_delete_ShaderMeshMessageLocation_destructor_closure */

SWIGINTERN int _wrap_new_ShaderComputeMessageLocation__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderComputeMessageLocation *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderComputeMessageLocation *)new ShaderComputeMessageLocation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderComputeMessageLocation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderComputeMessageLocation__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderComputeMessageLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderComputeMessageLocation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderComputeMessageLocation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderComputeMessageLocation" "', argument " "1"" of type '" "ShaderComputeMessageLocation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderComputeMessageLocation" "', argument " "1"" of type '" "ShaderComputeMessageLocation const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderComputeMessageLocation * >(argp1);
  result = (ShaderComputeMessageLocation *)new ShaderComputeMessageLocation((ShaderComputeMessageLocation const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderComputeMessageLocation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderComputeMessageLocation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderComputeMessageLocation",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderComputeMessageLocation__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderComputeMessageLocation__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderComputeMessageLocation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderComputeMessageLocation::ShaderComputeMessageLocation()\n"
    "    ShaderComputeMessageLocation::ShaderComputeMessageLocation(ShaderComputeMessageLocation const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderComputeMessageLocation___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderComputeMessageLocation *arg1 = (ShaderComputeMessageLocation *) 0 ;
  ShaderComputeMessageLocation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderComputeMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderComputeMessageLocation___eq__" "', argument " "1"" of type '" "ShaderComputeMessageLocation const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderComputeMessageLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderComputeMessageLocation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderComputeMessageLocation___eq__" "', argument " "2"" of type '" "ShaderComputeMessageLocation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderComputeMessageLocation___eq__" "', argument " "2"" of type '" "ShaderComputeMessageLocation const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderComputeMessageLocation * >(argp2);
  result = (bool)((ShaderComputeMessageLocation const *)arg1)->operator ==((ShaderComputeMessageLocation const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderComputeMessageLocation___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderComputeMessageLocation *arg1 = (ShaderComputeMessageLocation *) 0 ;
  ShaderComputeMessageLocation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderComputeMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderComputeMessageLocation___lt__" "', argument " "1"" of type '" "ShaderComputeMessageLocation const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderComputeMessageLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderComputeMessageLocation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderComputeMessageLocation___lt__" "', argument " "2"" of type '" "ShaderComputeMessageLocation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderComputeMessageLocation___lt__" "', argument " "2"" of type '" "ShaderComputeMessageLocation const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderComputeMessageLocation * >(argp2);
  result = (bool)((ShaderComputeMessageLocation const *)arg1)->operator <((ShaderComputeMessageLocation const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderComputeMessageLocation_workgroup_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderComputeMessageLocation *arg1 = (ShaderComputeMessageLocation *) 0 ;
  rdcfixedarray< uint32_t,3 > *arg2 = (rdcfixedarray< uint32_t,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderComputeMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderComputeMessageLocation_workgroup_set" "', argument " "1"" of type '" "ShaderComputeMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderComputeMessageLocation * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderComputeMessageLocation_workgroup_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderComputeMessageLocation_workgroup_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->workgroup = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderComputeMessageLocation_workgroup_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderComputeMessageLocation *arg1 = (ShaderComputeMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint32_t,3 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderComputeMessageLocation_workgroup_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderComputeMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderComputeMessageLocation_workgroup_get" "', argument " "1"" of type '" "ShaderComputeMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderComputeMessageLocation * >(argp1);
  result = (rdcfixedarray< uint32_t,3 > *)& ((arg1)->workgroup);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderComputeMessageLocation_thread_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderComputeMessageLocation *arg1 = (ShaderComputeMessageLocation *) 0 ;
  rdcfixedarray< uint32_t,3 > *arg2 = (rdcfixedarray< uint32_t,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderComputeMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderComputeMessageLocation_thread_set" "', argument " "1"" of type '" "ShaderComputeMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderComputeMessageLocation * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderComputeMessageLocation_thread_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderComputeMessageLocation_thread_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->thread = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderComputeMessageLocation_thread_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderComputeMessageLocation *arg1 = (ShaderComputeMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint32_t,3 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderComputeMessageLocation_thread_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderComputeMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderComputeMessageLocation_thread_get" "', argument " "1"" of type '" "ShaderComputeMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderComputeMessageLocation * >(argp1);
  result = (rdcfixedarray< uint32_t,3 > *)& ((arg1)->thread);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderComputeMessageLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderComputeMessageLocation *arg1 = (ShaderComputeMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderComputeMessageLocation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderComputeMessageLocation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderComputeMessageLocation" "', argument " "1"" of type '" "ShaderComputeMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderComputeMessageLocation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderComputeMessageLocation) /* defines _wrap_delete_ShaderComputeMessageLocation_destructor_closure */

SWIGINTERN PyObject *_wrap_ShaderVertexMessageLocation_vertexIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVertexMessageLocation *arg1 = (ShaderVertexMessageLocation *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVertexMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVertexMessageLocation_vertexIndex_set" "', argument " "1"" of type '" "ShaderVertexMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVertexMessageLocation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderVertexMessageLocation_vertexIndex_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->vertexIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVertexMessageLocation_vertexIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVertexMessageLocation *arg1 = (ShaderVertexMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVertexMessageLocation_vertexIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVertexMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVertexMessageLocation_vertexIndex_get" "', argument " "1"" of type '" "ShaderVertexMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVertexMessageLocation * >(argp1);
  result = (uint32_t) ((arg1)->vertexIndex);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVertexMessageLocation_instance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVertexMessageLocation *arg1 = (ShaderVertexMessageLocation *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVertexMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVertexMessageLocation_instance_set" "', argument " "1"" of type '" "ShaderVertexMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVertexMessageLocation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderVertexMessageLocation_instance_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->instance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVertexMessageLocation_instance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVertexMessageLocation *arg1 = (ShaderVertexMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVertexMessageLocation_instance_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVertexMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVertexMessageLocation_instance_get" "', argument " "1"" of type '" "ShaderVertexMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVertexMessageLocation * >(argp1);
  result = (uint32_t) ((arg1)->instance);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVertexMessageLocation_view_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVertexMessageLocation *arg1 = (ShaderVertexMessageLocation *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVertexMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVertexMessageLocation_view_set" "', argument " "1"" of type '" "ShaderVertexMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVertexMessageLocation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderVertexMessageLocation_view_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->view = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVertexMessageLocation_view_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVertexMessageLocation *arg1 = (ShaderVertexMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVertexMessageLocation_view_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVertexMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVertexMessageLocation_view_get" "', argument " "1"" of type '" "ShaderVertexMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVertexMessageLocation * >(argp1);
  result = (uint32_t) ((arg1)->view);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_ShaderVertexMessageLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVertexMessageLocation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ShaderVertexMessageLocation",0,0,0)) SWIG_fail;
  result = (ShaderVertexMessageLocation *)new ShaderVertexMessageLocation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderVertexMessageLocation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ShaderVertexMessageLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVertexMessageLocation *arg1 = (ShaderVertexMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderVertexMessageLocation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVertexMessageLocation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderVertexMessageLocation" "', argument " "1"" of type '" "ShaderVertexMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVertexMessageLocation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderVertexMessageLocation) /* defines _wrap_delete_ShaderVertexMessageLocation_destructor_closure */

SWIGINTERN PyObject *_wrap_ShaderPixelMessageLocation_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderPixelMessageLocation *arg1 = (ShaderPixelMessageLocation *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderPixelMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderPixelMessageLocation_x_set" "', argument " "1"" of type '" "ShaderPixelMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderPixelMessageLocation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderPixelMessageLocation_x_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderPixelMessageLocation_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderPixelMessageLocation *arg1 = (ShaderPixelMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderPixelMessageLocation_x_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderPixelMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderPixelMessageLocation_x_get" "', argument " "1"" of type '" "ShaderPixelMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderPixelMessageLocation * >(argp1);
  result = (uint32_t) ((arg1)->x);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderPixelMessageLocation_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderPixelMessageLocation *arg1 = (ShaderPixelMessageLocation *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderPixelMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderPixelMessageLocation_y_set" "', argument " "1"" of type '" "ShaderPixelMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderPixelMessageLocation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderPixelMessageLocation_y_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderPixelMessageLocation_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderPixelMessageLocation *arg1 = (ShaderPixelMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderPixelMessageLocation_y_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderPixelMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderPixelMessageLocation_y_get" "', argument " "1"" of type '" "ShaderPixelMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderPixelMessageLocation * >(argp1);
  result = (uint32_t) ((arg1)->y);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderPixelMessageLocation_sample_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderPixelMessageLocation *arg1 = (ShaderPixelMessageLocation *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderPixelMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderPixelMessageLocation_sample_set" "', argument " "1"" of type '" "ShaderPixelMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderPixelMessageLocation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderPixelMessageLocation_sample_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sample = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderPixelMessageLocation_sample_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderPixelMessageLocation *arg1 = (ShaderPixelMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderPixelMessageLocation_sample_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderPixelMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderPixelMessageLocation_sample_get" "', argument " "1"" of type '" "ShaderPixelMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderPixelMessageLocation * >(argp1);
  result = (uint32_t) ((arg1)->sample);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderPixelMessageLocation_primitive_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderPixelMessageLocation *arg1 = (ShaderPixelMessageLocation *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderPixelMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderPixelMessageLocation_primitive_set" "', argument " "1"" of type '" "ShaderPixelMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderPixelMessageLocation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderPixelMessageLocation_primitive_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->primitive = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderPixelMessageLocation_primitive_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderPixelMessageLocation *arg1 = (ShaderPixelMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderPixelMessageLocation_primitive_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderPixelMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderPixelMessageLocation_primitive_get" "', argument " "1"" of type '" "ShaderPixelMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderPixelMessageLocation * >(argp1);
  result = (uint32_t) ((arg1)->primitive);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderPixelMessageLocation_view_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderPixelMessageLocation *arg1 = (ShaderPixelMessageLocation *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderPixelMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderPixelMessageLocation_view_set" "', argument " "1"" of type '" "ShaderPixelMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderPixelMessageLocation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderPixelMessageLocation_view_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->view = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderPixelMessageLocation_view_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderPixelMessageLocation *arg1 = (ShaderPixelMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderPixelMessageLocation_view_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderPixelMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderPixelMessageLocation_view_get" "', argument " "1"" of type '" "ShaderPixelMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderPixelMessageLocation * >(argp1);
  result = (uint32_t) ((arg1)->view);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_ShaderPixelMessageLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderPixelMessageLocation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ShaderPixelMessageLocation",0,0,0)) SWIG_fail;
  result = (ShaderPixelMessageLocation *)new ShaderPixelMessageLocation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderPixelMessageLocation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ShaderPixelMessageLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderPixelMessageLocation *arg1 = (ShaderPixelMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderPixelMessageLocation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderPixelMessageLocation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderPixelMessageLocation" "', argument " "1"" of type '" "ShaderPixelMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderPixelMessageLocation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderPixelMessageLocation) /* defines _wrap_delete_ShaderPixelMessageLocation_destructor_closure */

SWIGINTERN PyObject *_wrap_ShaderGeometryMessageLocation_primitive_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderGeometryMessageLocation *arg1 = (ShaderGeometryMessageLocation *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderGeometryMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderGeometryMessageLocation_primitive_set" "', argument " "1"" of type '" "ShaderGeometryMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderGeometryMessageLocation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderGeometryMessageLocation_primitive_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->primitive = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderGeometryMessageLocation_primitive_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderGeometryMessageLocation *arg1 = (ShaderGeometryMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderGeometryMessageLocation_primitive_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderGeometryMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderGeometryMessageLocation_primitive_get" "', argument " "1"" of type '" "ShaderGeometryMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderGeometryMessageLocation * >(argp1);
  result = (uint32_t) ((arg1)->primitive);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderGeometryMessageLocation_view_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderGeometryMessageLocation *arg1 = (ShaderGeometryMessageLocation *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderGeometryMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderGeometryMessageLocation_view_set" "', argument " "1"" of type '" "ShaderGeometryMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderGeometryMessageLocation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderGeometryMessageLocation_view_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->view = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderGeometryMessageLocation_view_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderGeometryMessageLocation *arg1 = (ShaderGeometryMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderGeometryMessageLocation_view_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderGeometryMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderGeometryMessageLocation_view_get" "', argument " "1"" of type '" "ShaderGeometryMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderGeometryMessageLocation * >(argp1);
  result = (uint32_t) ((arg1)->view);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_ShaderGeometryMessageLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderGeometryMessageLocation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ShaderGeometryMessageLocation",0,0,0)) SWIG_fail;
  result = (ShaderGeometryMessageLocation *)new ShaderGeometryMessageLocation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderGeometryMessageLocation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ShaderGeometryMessageLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderGeometryMessageLocation *arg1 = (ShaderGeometryMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderGeometryMessageLocation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderGeometryMessageLocation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderGeometryMessageLocation" "', argument " "1"" of type '" "ShaderGeometryMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderGeometryMessageLocation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderGeometryMessageLocation) /* defines _wrap_delete_ShaderGeometryMessageLocation_destructor_closure */

SWIGINTERN PyObject *_wrap_ShaderMessageLocation_compute_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessageLocation *arg1 = (ShaderMessageLocation *) 0 ;
  ShaderComputeMessageLocation *arg2 = (ShaderComputeMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessageLocation_compute_set" "', argument " "1"" of type '" "ShaderMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessageLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderComputeMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderMessageLocation_compute_set" "', argument " "2"" of type '" "ShaderComputeMessageLocation *""'"); 
  }
  arg2 = reinterpret_cast< ShaderComputeMessageLocation * >(argp2);
  if (arg1) (arg1)->compute = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessageLocation_compute_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessageLocation *arg1 = (ShaderMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderComputeMessageLocation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderMessageLocation_compute_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessageLocation_compute_get" "', argument " "1"" of type '" "ShaderMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessageLocation * >(argp1);
  result = (ShaderComputeMessageLocation *)& ((arg1)->compute);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderComputeMessageLocation, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessageLocation_mesh_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessageLocation *arg1 = (ShaderMessageLocation *) 0 ;
  ShaderMeshMessageLocation *arg2 = (ShaderMeshMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessageLocation_mesh_set" "', argument " "1"" of type '" "ShaderMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessageLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderMeshMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderMessageLocation_mesh_set" "', argument " "2"" of type '" "ShaderMeshMessageLocation *""'"); 
  }
  arg2 = reinterpret_cast< ShaderMeshMessageLocation * >(argp2);
  if (arg1) (arg1)->mesh = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessageLocation_mesh_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessageLocation *arg1 = (ShaderMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderMeshMessageLocation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderMessageLocation_mesh_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessageLocation_mesh_get" "', argument " "1"" of type '" "ShaderMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessageLocation * >(argp1);
  result = (ShaderMeshMessageLocation *)& ((arg1)->mesh);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderMeshMessageLocation, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessageLocation_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessageLocation *arg1 = (ShaderMessageLocation *) 0 ;
  ShaderVertexMessageLocation *arg2 = (ShaderVertexMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessageLocation_vertex_set" "', argument " "1"" of type '" "ShaderMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessageLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderVertexMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderMessageLocation_vertex_set" "', argument " "2"" of type '" "ShaderVertexMessageLocation *""'"); 
  }
  arg2 = reinterpret_cast< ShaderVertexMessageLocation * >(argp2);
  if (arg1) (arg1)->vertex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessageLocation_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessageLocation *arg1 = (ShaderMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderVertexMessageLocation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderMessageLocation_vertex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessageLocation_vertex_get" "', argument " "1"" of type '" "ShaderMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessageLocation * >(argp1);
  result = (ShaderVertexMessageLocation *)& ((arg1)->vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderVertexMessageLocation, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessageLocation_pixel_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessageLocation *arg1 = (ShaderMessageLocation *) 0 ;
  ShaderPixelMessageLocation *arg2 = (ShaderPixelMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessageLocation_pixel_set" "', argument " "1"" of type '" "ShaderMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessageLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderPixelMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderMessageLocation_pixel_set" "', argument " "2"" of type '" "ShaderPixelMessageLocation *""'"); 
  }
  arg2 = reinterpret_cast< ShaderPixelMessageLocation * >(argp2);
  if (arg1) (arg1)->pixel = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessageLocation_pixel_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessageLocation *arg1 = (ShaderMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderPixelMessageLocation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderMessageLocation_pixel_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessageLocation_pixel_get" "', argument " "1"" of type '" "ShaderMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessageLocation * >(argp1);
  result = (ShaderPixelMessageLocation *)& ((arg1)->pixel);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderPixelMessageLocation, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessageLocation_geometry_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessageLocation *arg1 = (ShaderMessageLocation *) 0 ;
  ShaderGeometryMessageLocation *arg2 = (ShaderGeometryMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessageLocation_geometry_set" "', argument " "1"" of type '" "ShaderMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessageLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderGeometryMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderMessageLocation_geometry_set" "', argument " "2"" of type '" "ShaderGeometryMessageLocation *""'"); 
  }
  arg2 = reinterpret_cast< ShaderGeometryMessageLocation * >(argp2);
  if (arg1) (arg1)->geometry = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessageLocation_geometry_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessageLocation *arg1 = (ShaderMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderGeometryMessageLocation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderMessageLocation_geometry_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessageLocation_geometry_get" "', argument " "1"" of type '" "ShaderMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessageLocation * >(argp1);
  result = (ShaderGeometryMessageLocation *)& ((arg1)->geometry);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderGeometryMessageLocation, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_ShaderMessageLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessageLocation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ShaderMessageLocation",0,0,0)) SWIG_fail;
  result = (ShaderMessageLocation *)new ShaderMessageLocation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderMessageLocation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ShaderMessageLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessageLocation *arg1 = (ShaderMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderMessageLocation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessageLocation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderMessageLocation" "', argument " "1"" of type '" "ShaderMessageLocation *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessageLocation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderMessageLocation) /* defines _wrap_delete_ShaderMessageLocation_destructor_closure */

SWIGINTERN int _wrap_new_ShaderMessage__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderMessage *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderMessage *)new ShaderMessage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderMessage, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderMessage__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderMessage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderMessage *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderMessage,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderMessage" "', argument " "1"" of type '" "ShaderMessage const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderMessage" "', argument " "1"" of type '" "ShaderMessage const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessage * >(argp1);
  result = (ShaderMessage *)new ShaderMessage((ShaderMessage const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderMessage, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderMessage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderMessage",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderMessage__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderMessage__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderMessage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderMessage::ShaderMessage()\n"
    "    ShaderMessage::ShaderMessage(ShaderMessage const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderMessage___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessage *arg1 = (ShaderMessage *) 0 ;
  ShaderMessage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessage___eq__" "', argument " "1"" of type '" "ShaderMessage const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderMessage,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderMessage___eq__" "', argument " "2"" of type '" "ShaderMessage const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderMessage___eq__" "', argument " "2"" of type '" "ShaderMessage const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderMessage * >(argp2);
  result = (bool)((ShaderMessage const *)arg1)->operator ==((ShaderMessage const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessage___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessage *arg1 = (ShaderMessage *) 0 ;
  ShaderMessage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessage___lt__" "', argument " "1"" of type '" "ShaderMessage const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderMessage,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderMessage___lt__" "', argument " "2"" of type '" "ShaderMessage const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderMessage___lt__" "', argument " "2"" of type '" "ShaderMessage const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderMessage * >(argp2);
  result = (bool)((ShaderMessage const *)arg1)->operator <((ShaderMessage const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessage_stage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessage *arg1 = (ShaderMessage *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessage_stage_set" "', argument " "1"" of type '" "ShaderMessage *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessage * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderMessage_stage_set" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  if (arg1) (arg1)->stage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessage_stage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessage *arg1 = (ShaderMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStage result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderMessage_stage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessage_stage_get" "', argument " "1"" of type '" "ShaderMessage *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessage * >(argp1);
  result = (ShaderStage) ((arg1)->stage);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessage_disassemblyLine_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessage *arg1 = (ShaderMessage *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessage_disassemblyLine_set" "', argument " "1"" of type '" "ShaderMessage *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessage * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderMessage_disassemblyLine_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->disassemblyLine = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessage_disassemblyLine_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessage *arg1 = (ShaderMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderMessage_disassemblyLine_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessage_disassemblyLine_get" "', argument " "1"" of type '" "ShaderMessage *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessage * >(argp1);
  result = (int32_t) ((arg1)->disassemblyLine);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessage_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessage *arg1 = (ShaderMessage *) 0 ;
  ShaderMessageLocation *arg2 = (ShaderMessageLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessage_location_set" "', argument " "1"" of type '" "ShaderMessage *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderMessageLocation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderMessage_location_set" "', argument " "2"" of type '" "ShaderMessageLocation *""'"); 
  }
  arg2 = reinterpret_cast< ShaderMessageLocation * >(argp2);
  if (arg1) (arg1)->location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessage_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessage *arg1 = (ShaderMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderMessageLocation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderMessage_location_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessage_location_get" "', argument " "1"" of type '" "ShaderMessage *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessage * >(argp1);
  result = (ShaderMessageLocation *)& ((arg1)->location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderMessageLocation, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessage_message_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessage *arg1 = (ShaderMessage *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessage_message_set" "', argument " "1"" of type '" "ShaderMessage *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessage * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderMessage_message_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->message = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderMessage_message_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessage *arg1 = (ShaderMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderMessage_message_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderMessage_message_get" "', argument " "1"" of type '" "ShaderMessage *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessage * >(argp1);
  result =  ((arg1)->message);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderMessage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderMessage *arg1 = (ShaderMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderMessage",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderMessage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderMessage" "', argument " "1"" of type '" "ShaderMessage *""'"); 
  }
  arg1 = reinterpret_cast< ShaderMessage * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderMessage) /* defines _wrap_delete_ShaderMessage_destructor_closure */

SWIGINTERN int _wrap_new_D3D11Layout__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D11Pipe::Layout *)new D3D11Pipe::Layout();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Layout, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11Layout__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D11Pipe::Layout *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D11Pipe__Layout,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D11Layout" "', argument " "1"" of type '" "D3D11Pipe::Layout const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D11Layout" "', argument " "1"" of type '" "D3D11Pipe::Layout const &""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  result = (D3D11Pipe::Layout *)new D3D11Pipe::Layout((D3D11Pipe::Layout const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Layout, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11Layout(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D11Layout",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D11Layout__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D11Layout__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D11Layout'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D11Pipe::Layout::Layout()\n"
    "    D3D11Pipe::Layout::Layout(D3D11Pipe::Layout const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D11Layout___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  D3D11Pipe::Layout *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout___eq__" "', argument " "1"" of type '" "D3D11Pipe::Layout const *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D11Pipe__Layout,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11Layout___eq__" "', argument " "2"" of type '" "D3D11Pipe::Layout const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D11Layout___eq__" "', argument " "2"" of type '" "D3D11Pipe::Layout const &""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::Layout * >(argp2);
  result = (bool)((D3D11Pipe::Layout const *)arg1)->operator ==((D3D11Pipe::Layout const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  D3D11Pipe::Layout *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout___lt__" "', argument " "1"" of type '" "D3D11Pipe::Layout const *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D11Pipe__Layout,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11Layout___lt__" "', argument " "2"" of type '" "D3D11Pipe::Layout const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D11Layout___lt__" "', argument " "2"" of type '" "D3D11Pipe::Layout const &""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::Layout * >(argp2);
  result = (bool)((D3D11Pipe::Layout const *)arg1)->operator <((D3D11Pipe::Layout const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_semanticName_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_semanticName_set" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D11Layout_semanticName_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->semanticName = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_semanticName_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Layout_semanticName_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_semanticName_get" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  result =  ((arg1)->semanticName);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_semanticIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_semanticIndex_set" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11Layout_semanticIndex_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->semanticIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_semanticIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Layout_semanticIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_semanticIndex_get" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  result = (uint32_t) ((arg1)->semanticIndex);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_format_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  ResourceFormat *arg2 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_format_set" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11Layout_format_set" "', argument " "2"" of type '" "ResourceFormat *""'"); 
  }
  arg2 = reinterpret_cast< ResourceFormat * >(argp2);
  if (arg1) (arg1)->format = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_format_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceFormat *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Layout_format_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_format_get" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  result = (ResourceFormat *)& ((arg1)->format);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_inputSlot_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_inputSlot_set" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11Layout_inputSlot_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->inputSlot = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_inputSlot_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Layout_inputSlot_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_inputSlot_get" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  result = (uint32_t) ((arg1)->inputSlot);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_byteOffset_set" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11Layout_byteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Layout_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_byteOffset_get" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  result = (uint32_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_perInstance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_perInstance_set" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11Layout_perInstance_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->perInstance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_perInstance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Layout_perInstance_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_perInstance_get" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  result = (bool) ((arg1)->perInstance);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_instanceDataStepRate_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_instanceDataStepRate_set" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11Layout_instanceDataStepRate_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->instanceDataStepRate = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Layout_instanceDataStepRate_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Layout_instanceDataStepRate_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Layout_instanceDataStepRate_get" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  result = (uint32_t) ((arg1)->instanceDataStepRate);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11Layout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Layout *arg1 = (D3D11Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11Layout",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Layout, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11Layout" "', argument " "1"" of type '" "D3D11Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Layout * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11Layout) /* defines _wrap_delete_D3D11Layout_destructor_closure */

SWIGINTERN int _wrap_new_D3D11VertexBuffer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D11Pipe::VertexBuffer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D11Pipe::VertexBuffer *)new D3D11Pipe::VertexBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__VertexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11VertexBuffer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D11Pipe::VertexBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D11Pipe::VertexBuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D11Pipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D11VertexBuffer" "', argument " "1"" of type '" "D3D11Pipe::VertexBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D11VertexBuffer" "', argument " "1"" of type '" "D3D11Pipe::VertexBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::VertexBuffer * >(argp1);
  result = (D3D11Pipe::VertexBuffer *)new D3D11Pipe::VertexBuffer((D3D11Pipe::VertexBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__VertexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11VertexBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D11VertexBuffer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D11VertexBuffer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D11VertexBuffer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D11VertexBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D11Pipe::VertexBuffer::VertexBuffer()\n"
    "    D3D11Pipe::VertexBuffer::VertexBuffer(D3D11Pipe::VertexBuffer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D11VertexBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::VertexBuffer *arg1 = (D3D11Pipe::VertexBuffer *) 0 ;
  D3D11Pipe::VertexBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11VertexBuffer___eq__" "', argument " "1"" of type '" "D3D11Pipe::VertexBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::VertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D11Pipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11VertexBuffer___eq__" "', argument " "2"" of type '" "D3D11Pipe::VertexBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D11VertexBuffer___eq__" "', argument " "2"" of type '" "D3D11Pipe::VertexBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::VertexBuffer * >(argp2);
  result = (bool)((D3D11Pipe::VertexBuffer const *)arg1)->operator ==((D3D11Pipe::VertexBuffer const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11VertexBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::VertexBuffer *arg1 = (D3D11Pipe::VertexBuffer *) 0 ;
  D3D11Pipe::VertexBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11VertexBuffer___lt__" "', argument " "1"" of type '" "D3D11Pipe::VertexBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::VertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D11Pipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11VertexBuffer___lt__" "', argument " "2"" of type '" "D3D11Pipe::VertexBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D11VertexBuffer___lt__" "', argument " "2"" of type '" "D3D11Pipe::VertexBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::VertexBuffer * >(argp2);
  result = (bool)((D3D11Pipe::VertexBuffer const *)arg1)->operator <((D3D11Pipe::VertexBuffer const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11VertexBuffer_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::VertexBuffer *arg1 = (D3D11Pipe::VertexBuffer *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11VertexBuffer_resourceId_set" "', argument " "1"" of type '" "D3D11Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::VertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11VertexBuffer_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11VertexBuffer_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::VertexBuffer *arg1 = (D3D11Pipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11VertexBuffer_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11VertexBuffer_resourceId_get" "', argument " "1"" of type '" "D3D11Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::VertexBuffer * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11VertexBuffer_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::VertexBuffer *arg1 = (D3D11Pipe::VertexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11VertexBuffer_byteOffset_set" "', argument " "1"" of type '" "D3D11Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::VertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11VertexBuffer_byteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11VertexBuffer_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::VertexBuffer *arg1 = (D3D11Pipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11VertexBuffer_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11VertexBuffer_byteOffset_get" "', argument " "1"" of type '" "D3D11Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::VertexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11VertexBuffer_byteStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::VertexBuffer *arg1 = (D3D11Pipe::VertexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11VertexBuffer_byteStride_set" "', argument " "1"" of type '" "D3D11Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::VertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11VertexBuffer_byteStride_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11VertexBuffer_byteStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::VertexBuffer *arg1 = (D3D11Pipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11VertexBuffer_byteStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11VertexBuffer_byteStride_get" "', argument " "1"" of type '" "D3D11Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::VertexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteStride);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11VertexBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::VertexBuffer *arg1 = (D3D11Pipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11VertexBuffer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__VertexBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11VertexBuffer" "', argument " "1"" of type '" "D3D11Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::VertexBuffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11VertexBuffer) /* defines _wrap_delete_D3D11VertexBuffer_destructor_closure */

SWIGINTERN int _wrap_new_D3D11IndexBuffer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D11Pipe::IndexBuffer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D11Pipe::IndexBuffer *)new D3D11Pipe::IndexBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__IndexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11IndexBuffer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D11Pipe::IndexBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D11Pipe::IndexBuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D11Pipe__IndexBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D11IndexBuffer" "', argument " "1"" of type '" "D3D11Pipe::IndexBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D11IndexBuffer" "', argument " "1"" of type '" "D3D11Pipe::IndexBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::IndexBuffer * >(argp1);
  result = (D3D11Pipe::IndexBuffer *)new D3D11Pipe::IndexBuffer((D3D11Pipe::IndexBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__IndexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11IndexBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D11IndexBuffer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D11IndexBuffer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D11IndexBuffer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D11IndexBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D11Pipe::IndexBuffer::IndexBuffer()\n"
    "    D3D11Pipe::IndexBuffer::IndexBuffer(D3D11Pipe::IndexBuffer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D11IndexBuffer_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::IndexBuffer *arg1 = (D3D11Pipe::IndexBuffer *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11IndexBuffer_resourceId_set" "', argument " "1"" of type '" "D3D11Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::IndexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11IndexBuffer_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11IndexBuffer_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::IndexBuffer *arg1 = (D3D11Pipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11IndexBuffer_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11IndexBuffer_resourceId_get" "', argument " "1"" of type '" "D3D11Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::IndexBuffer * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11IndexBuffer_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::IndexBuffer *arg1 = (D3D11Pipe::IndexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11IndexBuffer_byteOffset_set" "', argument " "1"" of type '" "D3D11Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::IndexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11IndexBuffer_byteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11IndexBuffer_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::IndexBuffer *arg1 = (D3D11Pipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11IndexBuffer_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11IndexBuffer_byteOffset_get" "', argument " "1"" of type '" "D3D11Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::IndexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11IndexBuffer_byteStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::IndexBuffer *arg1 = (D3D11Pipe::IndexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11IndexBuffer_byteStride_set" "', argument " "1"" of type '" "D3D11Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::IndexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11IndexBuffer_byteStride_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11IndexBuffer_byteStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::IndexBuffer *arg1 = (D3D11Pipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11IndexBuffer_byteStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11IndexBuffer_byteStride_get" "', argument " "1"" of type '" "D3D11Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::IndexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteStride);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11IndexBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::IndexBuffer *arg1 = (D3D11Pipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11IndexBuffer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__IndexBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11IndexBuffer" "', argument " "1"" of type '" "D3D11Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::IndexBuffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11IndexBuffer) /* defines _wrap_delete_D3D11IndexBuffer_destructor_closure */

SWIGINTERN int _wrap_new_D3D11InputAssembly__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D11Pipe::InputAssembly *)new D3D11Pipe::InputAssembly();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__InputAssembly, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11InputAssembly__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D11Pipe::InputAssembly *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D11Pipe__InputAssembly,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D11InputAssembly" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D11InputAssembly" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly const &""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  result = (D3D11Pipe::InputAssembly *)new D3D11Pipe::InputAssembly((D3D11Pipe::InputAssembly const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__InputAssembly, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11InputAssembly(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D11InputAssembly",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D11InputAssembly__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D11InputAssembly__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D11InputAssembly'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D11Pipe::InputAssembly::InputAssembly()\n"
    "    D3D11Pipe::InputAssembly::InputAssembly(D3D11Pipe::InputAssembly const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D11InputAssembly_layouts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = (D3D11Pipe::InputAssembly *) 0 ;
  rdcarray< D3D11Pipe::Layout > *arg2 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11InputAssembly_layouts_set" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D11InputAssembly_layouts_set' argument 2 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D11InputAssembly_layouts_set' argument 2 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->layouts = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11InputAssembly_layouts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = (D3D11Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< D3D11Pipe::Layout > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11InputAssembly_layouts_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11InputAssembly_layouts_get" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  result = (rdcarray< D3D11Pipe::Layout > *)& ((arg1)->layouts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_D3D11Pipe__Layout_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11InputAssembly_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = (D3D11Pipe::InputAssembly *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11InputAssembly_resourceId_set" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11InputAssembly_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11InputAssembly_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = (D3D11Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11InputAssembly_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11InputAssembly_resourceId_get" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11InputAssembly_bytecode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = (D3D11Pipe::InputAssembly *) 0 ;
  ShaderReflection *arg2 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11InputAssembly_bytecode_set" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderReflection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11InputAssembly_bytecode_set" "', argument " "2"" of type '" "ShaderReflection const *""'"); 
  }
  arg2 = reinterpret_cast< ShaderReflection * >(argp2);
  if (arg1) (arg1)->bytecode = (ShaderReflection const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11InputAssembly_bytecode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = (D3D11Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderReflection *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11InputAssembly_bytecode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11InputAssembly_bytecode_get" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  result = (ShaderReflection *) ((arg1)->bytecode);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11InputAssembly_vertexBuffers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = (D3D11Pipe::InputAssembly *) 0 ;
  rdcarray< D3D11Pipe::VertexBuffer > *arg2 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11InputAssembly_vertexBuffers_set" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D11InputAssembly_vertexBuffers_set' argument 2 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D11InputAssembly_vertexBuffers_set' argument 2 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->vertexBuffers = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11InputAssembly_vertexBuffers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = (D3D11Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< D3D11Pipe::VertexBuffer > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11InputAssembly_vertexBuffers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11InputAssembly_vertexBuffers_get" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  result = (rdcarray< D3D11Pipe::VertexBuffer > *)& ((arg1)->vertexBuffers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_D3D11Pipe__VertexBuffer_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11InputAssembly_indexBuffer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = (D3D11Pipe::InputAssembly *) 0 ;
  D3D11Pipe::IndexBuffer *arg2 = (D3D11Pipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11InputAssembly_indexBuffer_set" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11InputAssembly_indexBuffer_set" "', argument " "2"" of type '" "D3D11Pipe::IndexBuffer *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::IndexBuffer * >(argp2);
  if (arg1) (arg1)->indexBuffer = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11InputAssembly_indexBuffer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = (D3D11Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::IndexBuffer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11InputAssembly_indexBuffer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11InputAssembly_indexBuffer_get" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  result = (D3D11Pipe::IndexBuffer *)& ((arg1)->indexBuffer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__IndexBuffer, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11InputAssembly_topology_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = (D3D11Pipe::InputAssembly *) 0 ;
  Topology arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11InputAssembly_topology_set" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11InputAssembly_topology_set" "', argument " "2"" of type '" "Topology""'");
  } 
  arg2 = static_cast< Topology >(val2);
  if (arg1) (arg1)->topology = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11InputAssembly_topology_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = (D3D11Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Topology result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11InputAssembly_topology_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11InputAssembly_topology_get" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  result = (Topology) ((arg1)->topology);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_Topology->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11InputAssembly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::InputAssembly *arg1 = (D3D11Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11InputAssembly",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__InputAssembly, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11InputAssembly" "', argument " "1"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11InputAssembly) /* defines _wrap_delete_D3D11InputAssembly_destructor_closure */

SWIGINTERN int _wrap_new_D3D11Shader__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D11Pipe::Shader *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D11Pipe::Shader *)new D3D11Pipe::Shader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Shader, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11Shader__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D11Pipe::Shader *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D11Pipe::Shader *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D11Pipe__Shader,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D11Shader" "', argument " "1"" of type '" "D3D11Pipe::Shader const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D11Shader" "', argument " "1"" of type '" "D3D11Pipe::Shader const &""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Shader * >(argp1);
  result = (D3D11Pipe::Shader *)new D3D11Pipe::Shader((D3D11Pipe::Shader const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Shader, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11Shader(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D11Shader",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D11Shader__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D11Shader__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D11Shader'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D11Pipe::Shader::Shader()\n"
    "    D3D11Pipe::Shader::Shader(D3D11Pipe::Shader const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D11Shader_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Shader *arg1 = (D3D11Pipe::Shader *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Shader_resourceId_set" "', argument " "1"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Shader * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11Shader_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Shader_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Shader *arg1 = (D3D11Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Shader_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Shader_resourceId_get" "', argument " "1"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Shader * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Shader_reflection_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Shader *arg1 = (D3D11Pipe::Shader *) 0 ;
  ShaderReflection *arg2 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Shader_reflection_set" "', argument " "1"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Shader * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderReflection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11Shader_reflection_set" "', argument " "2"" of type '" "ShaderReflection const *""'"); 
  }
  arg2 = reinterpret_cast< ShaderReflection * >(argp2);
  if (arg1) (arg1)->reflection = (ShaderReflection const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Shader_reflection_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Shader *arg1 = (D3D11Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderReflection *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Shader_reflection_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Shader_reflection_get" "', argument " "1"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Shader * >(argp1);
  result = (ShaderReflection *) ((arg1)->reflection);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Shader_stage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Shader *arg1 = (D3D11Pipe::Shader *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Shader_stage_set" "', argument " "1"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Shader * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11Shader_stage_set" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  if (arg1) (arg1)->stage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Shader_stage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Shader *arg1 = (D3D11Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStage result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Shader_stage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Shader_stage_get" "', argument " "1"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Shader * >(argp1);
  result = (ShaderStage) ((arg1)->stage);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Shader_classInstances_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Shader *arg1 = (D3D11Pipe::Shader *) 0 ;
  rdcarray< rdcstr > *arg2 = (rdcarray< rdcstr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Shader_classInstances_set" "', argument " "1"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Shader * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D11Shader_classInstances_set' argument 2 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D11Shader_classInstances_set' argument 2 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->classInstances = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Shader_classInstances_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Shader *arg1 = (D3D11Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< rdcstr > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Shader_classInstances_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Shader_classInstances_get" "', argument " "1"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Shader * >(argp1);
  result = (rdcarray< rdcstr > *)& ((arg1)->classInstances);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_rdcstr_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11Shader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Shader *arg1 = (D3D11Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11Shader",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Shader, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11Shader" "', argument " "1"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Shader * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11Shader) /* defines _wrap_delete_D3D11Shader_destructor_closure */

SWIGINTERN int _wrap_new_D3D11StreamOutBind__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOutBind *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D11Pipe::StreamOutBind *)new D3D11Pipe::StreamOutBind();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__StreamOutBind, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11StreamOutBind__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOutBind *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D11Pipe::StreamOutBind *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D11Pipe__StreamOutBind,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D11StreamOutBind" "', argument " "1"" of type '" "D3D11Pipe::StreamOutBind const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D11StreamOutBind" "', argument " "1"" of type '" "D3D11Pipe::StreamOutBind const &""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOutBind * >(argp1);
  result = (D3D11Pipe::StreamOutBind *)new D3D11Pipe::StreamOutBind((D3D11Pipe::StreamOutBind const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__StreamOutBind, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11StreamOutBind(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D11StreamOutBind",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D11StreamOutBind__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D11StreamOutBind__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D11StreamOutBind'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D11Pipe::StreamOutBind::StreamOutBind()\n"
    "    D3D11Pipe::StreamOutBind::StreamOutBind(D3D11Pipe::StreamOutBind const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D11StreamOutBind___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOutBind *arg1 = (D3D11Pipe::StreamOutBind *) 0 ;
  D3D11Pipe::StreamOutBind *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11StreamOutBind___eq__" "', argument " "1"" of type '" "D3D11Pipe::StreamOutBind const *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOutBind * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D11Pipe__StreamOutBind,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11StreamOutBind___eq__" "', argument " "2"" of type '" "D3D11Pipe::StreamOutBind const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D11StreamOutBind___eq__" "', argument " "2"" of type '" "D3D11Pipe::StreamOutBind const &""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::StreamOutBind * >(argp2);
  result = (bool)((D3D11Pipe::StreamOutBind const *)arg1)->operator ==((D3D11Pipe::StreamOutBind const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11StreamOutBind___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOutBind *arg1 = (D3D11Pipe::StreamOutBind *) 0 ;
  D3D11Pipe::StreamOutBind *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11StreamOutBind___lt__" "', argument " "1"" of type '" "D3D11Pipe::StreamOutBind const *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOutBind * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D11Pipe__StreamOutBind,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11StreamOutBind___lt__" "', argument " "2"" of type '" "D3D11Pipe::StreamOutBind const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D11StreamOutBind___lt__" "', argument " "2"" of type '" "D3D11Pipe::StreamOutBind const &""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::StreamOutBind * >(argp2);
  result = (bool)((D3D11Pipe::StreamOutBind const *)arg1)->operator <((D3D11Pipe::StreamOutBind const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11StreamOutBind_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOutBind *arg1 = (D3D11Pipe::StreamOutBind *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11StreamOutBind_resourceId_set" "', argument " "1"" of type '" "D3D11Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOutBind * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11StreamOutBind_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11StreamOutBind_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOutBind *arg1 = (D3D11Pipe::StreamOutBind *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11StreamOutBind_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11StreamOutBind_resourceId_get" "', argument " "1"" of type '" "D3D11Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOutBind * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11StreamOutBind_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOutBind *arg1 = (D3D11Pipe::StreamOutBind *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11StreamOutBind_byteOffset_set" "', argument " "1"" of type '" "D3D11Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOutBind * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11StreamOutBind_byteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11StreamOutBind_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOutBind *arg1 = (D3D11Pipe::StreamOutBind *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11StreamOutBind_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11StreamOutBind_byteOffset_get" "', argument " "1"" of type '" "D3D11Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOutBind * >(argp1);
  result = (uint32_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11StreamOutBind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOutBind *arg1 = (D3D11Pipe::StreamOutBind *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11StreamOutBind",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__StreamOutBind, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11StreamOutBind" "', argument " "1"" of type '" "D3D11Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOutBind * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11StreamOutBind) /* defines _wrap_delete_D3D11StreamOutBind_destructor_closure */

SWIGINTERN int _wrap_new_D3D11StreamOut__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOut *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D11Pipe::StreamOut *)new D3D11Pipe::StreamOut();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__StreamOut, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11StreamOut__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOut *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D11Pipe::StreamOut *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D11Pipe__StreamOut,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D11StreamOut" "', argument " "1"" of type '" "D3D11Pipe::StreamOut const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D11StreamOut" "', argument " "1"" of type '" "D3D11Pipe::StreamOut const &""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOut * >(argp1);
  result = (D3D11Pipe::StreamOut *)new D3D11Pipe::StreamOut((D3D11Pipe::StreamOut const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__StreamOut, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11StreamOut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D11StreamOut",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D11StreamOut__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D11StreamOut__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D11StreamOut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D11Pipe::StreamOut::StreamOut()\n"
    "    D3D11Pipe::StreamOut::StreamOut(D3D11Pipe::StreamOut const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D11StreamOut_outputs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOut *arg1 = (D3D11Pipe::StreamOut *) 0 ;
  rdcarray< D3D11Pipe::StreamOutBind > *arg2 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__StreamOut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11StreamOut_outputs_set" "', argument " "1"" of type '" "D3D11Pipe::StreamOut *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOut * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D11StreamOut_outputs_set' argument 2 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D11StreamOut_outputs_set' argument 2 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->outputs = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11StreamOut_outputs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOut *arg1 = (D3D11Pipe::StreamOut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< D3D11Pipe::StreamOutBind > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11StreamOut_outputs_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__StreamOut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11StreamOut_outputs_get" "', argument " "1"" of type '" "D3D11Pipe::StreamOut *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOut * >(argp1);
  result = (rdcarray< D3D11Pipe::StreamOutBind > *)& ((arg1)->outputs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_D3D11Pipe__StreamOutBind_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11StreamOut_rasterizedStream_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOut *arg1 = (D3D11Pipe::StreamOut *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__StreamOut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11StreamOut_rasterizedStream_set" "', argument " "1"" of type '" "D3D11Pipe::StreamOut *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOut * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11StreamOut_rasterizedStream_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->rasterizedStream = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11StreamOut_rasterizedStream_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOut *arg1 = (D3D11Pipe::StreamOut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11StreamOut_rasterizedStream_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__StreamOut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11StreamOut_rasterizedStream_get" "', argument " "1"" of type '" "D3D11Pipe::StreamOut *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOut * >(argp1);
  result = (uint32_t) ((arg1)->rasterizedStream);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11StreamOut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::StreamOut *arg1 = (D3D11Pipe::StreamOut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11StreamOut",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__StreamOut, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11StreamOut" "', argument " "1"" of type '" "D3D11Pipe::StreamOut *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::StreamOut * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11StreamOut) /* defines _wrap_delete_D3D11StreamOut_destructor_closure */

SWIGINTERN int _wrap_new_D3D11RasterizerState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D11Pipe::RasterizerState *)new D3D11Pipe::RasterizerState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__RasterizerState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11RasterizerState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D11Pipe::RasterizerState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D11Pipe__RasterizerState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D11RasterizerState" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D11RasterizerState" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState const &""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (D3D11Pipe::RasterizerState *)new D3D11Pipe::RasterizerState((D3D11Pipe::RasterizerState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__RasterizerState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11RasterizerState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D11RasterizerState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D11RasterizerState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D11RasterizerState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D11RasterizerState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D11Pipe::RasterizerState::RasterizerState()\n"
    "    D3D11Pipe::RasterizerState::RasterizerState(D3D11Pipe::RasterizerState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_resourceId_set" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11RasterizerState_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11RasterizerState_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_resourceId_get" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_fillMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  FillMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_fillMode_set" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11RasterizerState_fillMode_set" "', argument " "2"" of type '" "FillMode""'");
  } 
  arg2 = static_cast< FillMode >(val2);
  if (arg1) (arg1)->fillMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_fillMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FillMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11RasterizerState_fillMode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_fillMode_get" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (FillMode) ((arg1)->fillMode);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_FillMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_cullMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  CullMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_cullMode_set" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11RasterizerState_cullMode_set" "', argument " "2"" of type '" "CullMode""'");
  } 
  arg2 = static_cast< CullMode >(val2);
  if (arg1) (arg1)->cullMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_cullMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CullMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11RasterizerState_cullMode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_cullMode_get" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (CullMode) ((arg1)->cullMode);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CullMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_frontCCW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_frontCCW_set" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11RasterizerState_frontCCW_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->frontCCW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_frontCCW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11RasterizerState_frontCCW_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_frontCCW_get" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->frontCCW);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_depthBias_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_depthBias_set" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11RasterizerState_depthBias_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->depthBias = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_depthBias_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11RasterizerState_depthBias_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_depthBias_get" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (int32_t) ((arg1)->depthBias);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_depthBiasClamp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_depthBiasClamp_set" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11RasterizerState_depthBiasClamp_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->depthBiasClamp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_depthBiasClamp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11RasterizerState_depthBiasClamp_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_depthBiasClamp_get" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (float) ((arg1)->depthBiasClamp);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_slopeScaledDepthBias_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_slopeScaledDepthBias_set" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11RasterizerState_slopeScaledDepthBias_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->slopeScaledDepthBias = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_slopeScaledDepthBias_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11RasterizerState_slopeScaledDepthBias_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_slopeScaledDepthBias_get" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (float) ((arg1)->slopeScaledDepthBias);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_depthClip_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_depthClip_set" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11RasterizerState_depthClip_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthClip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_depthClip_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11RasterizerState_depthClip_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_depthClip_get" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->depthClip);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_scissorEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_scissorEnable_set" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11RasterizerState_scissorEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->scissorEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_scissorEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11RasterizerState_scissorEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_scissorEnable_get" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->scissorEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_multisampleEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_multisampleEnable_set" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11RasterizerState_multisampleEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->multisampleEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_multisampleEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11RasterizerState_multisampleEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_multisampleEnable_get" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->multisampleEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_antialiasedLines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_antialiasedLines_set" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11RasterizerState_antialiasedLines_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->antialiasedLines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_antialiasedLines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11RasterizerState_antialiasedLines_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_antialiasedLines_get" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->antialiasedLines);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_forcedSampleCount_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_forcedSampleCount_set" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11RasterizerState_forcedSampleCount_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->forcedSampleCount = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_forcedSampleCount_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11RasterizerState_forcedSampleCount_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_forcedSampleCount_get" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (uint32_t) ((arg1)->forcedSampleCount);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_conservativeRasterization_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  ConservativeRaster arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_conservativeRasterization_set" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11RasterizerState_conservativeRasterization_set" "', argument " "2"" of type '" "ConservativeRaster""'");
  } 
  arg2 = static_cast< ConservativeRaster >(val2);
  if (arg1) (arg1)->conservativeRasterization = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11RasterizerState_conservativeRasterization_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConservativeRaster result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11RasterizerState_conservativeRasterization_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11RasterizerState_conservativeRasterization_get" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  result = (ConservativeRaster) ((arg1)->conservativeRasterization);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ConservativeRaster->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11RasterizerState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::RasterizerState *arg1 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11RasterizerState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__RasterizerState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11RasterizerState" "', argument " "1"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11RasterizerState) /* defines _wrap_delete_D3D11RasterizerState_destructor_closure */

SWIGINTERN int _wrap_new_D3D11Rasterizer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D11Pipe::Rasterizer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D11Pipe::Rasterizer *)new D3D11Pipe::Rasterizer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Rasterizer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11Rasterizer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D11Pipe::Rasterizer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D11Pipe::Rasterizer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D11Pipe__Rasterizer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D11Rasterizer" "', argument " "1"" of type '" "D3D11Pipe::Rasterizer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D11Rasterizer" "', argument " "1"" of type '" "D3D11Pipe::Rasterizer const &""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Rasterizer * >(argp1);
  result = (D3D11Pipe::Rasterizer *)new D3D11Pipe::Rasterizer((D3D11Pipe::Rasterizer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Rasterizer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11Rasterizer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D11Rasterizer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D11Rasterizer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D11Rasterizer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D11Rasterizer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D11Pipe::Rasterizer::Rasterizer()\n"
    "    D3D11Pipe::Rasterizer::Rasterizer(D3D11Pipe::Rasterizer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D11Rasterizer_viewports_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Rasterizer *arg1 = (D3D11Pipe::Rasterizer *) 0 ;
  rdcarray< Viewport > *arg2 = (rdcarray< Viewport > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Rasterizer_viewports_set" "', argument " "1"" of type '" "D3D11Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Rasterizer * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D11Rasterizer_viewports_set' argument 2 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D11Rasterizer_viewports_set' argument 2 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->viewports = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Rasterizer_viewports_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Rasterizer *arg1 = (D3D11Pipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< Viewport > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Rasterizer_viewports_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Rasterizer_viewports_get" "', argument " "1"" of type '" "D3D11Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Rasterizer * >(argp1);
  result = (rdcarray< Viewport > *)& ((arg1)->viewports);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_Viewport_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Rasterizer_scissors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Rasterizer *arg1 = (D3D11Pipe::Rasterizer *) 0 ;
  rdcarray< Scissor > *arg2 = (rdcarray< Scissor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Rasterizer_scissors_set" "', argument " "1"" of type '" "D3D11Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Rasterizer * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D11Rasterizer_scissors_set' argument 2 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D11Rasterizer_scissors_set' argument 2 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->scissors = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Rasterizer_scissors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Rasterizer *arg1 = (D3D11Pipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< Scissor > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Rasterizer_scissors_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Rasterizer_scissors_get" "', argument " "1"" of type '" "D3D11Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Rasterizer * >(argp1);
  result = (rdcarray< Scissor > *)& ((arg1)->scissors);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_Scissor_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Rasterizer_state_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Rasterizer *arg1 = (D3D11Pipe::Rasterizer *) 0 ;
  D3D11Pipe::RasterizerState *arg2 = (D3D11Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Rasterizer_state_set" "', argument " "1"" of type '" "D3D11Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Rasterizer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11Rasterizer_state_set" "', argument " "2"" of type '" "D3D11Pipe::RasterizerState *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::RasterizerState * >(argp2);
  if (arg1) (arg1)->state = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Rasterizer_state_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Rasterizer *arg1 = (D3D11Pipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::RasterizerState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Rasterizer_state_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Rasterizer_state_get" "', argument " "1"" of type '" "D3D11Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Rasterizer * >(argp1);
  result = (D3D11Pipe::RasterizerState *)& ((arg1)->state);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__RasterizerState, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11Rasterizer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Rasterizer *arg1 = (D3D11Pipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11Rasterizer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Rasterizer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11Rasterizer" "', argument " "1"" of type '" "D3D11Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Rasterizer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11Rasterizer) /* defines _wrap_delete_D3D11Rasterizer_destructor_closure */

SWIGINTERN int _wrap_new_D3D11DepthStencilState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D11Pipe::DepthStencilState *)new D3D11Pipe::DepthStencilState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__DepthStencilState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11DepthStencilState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D11Pipe::DepthStencilState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D11Pipe__DepthStencilState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D11DepthStencilState" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D11DepthStencilState" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState const &""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  result = (D3D11Pipe::DepthStencilState *)new D3D11Pipe::DepthStencilState((D3D11Pipe::DepthStencilState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__DepthStencilState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11DepthStencilState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D11DepthStencilState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D11DepthStencilState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D11DepthStencilState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D11DepthStencilState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D11Pipe::DepthStencilState::DepthStencilState()\n"
    "    D3D11Pipe::DepthStencilState::DepthStencilState(D3D11Pipe::DepthStencilState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_resourceId_set" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11DepthStencilState_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11DepthStencilState_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_resourceId_get" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_depthEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_depthEnable_set" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11DepthStencilState_depthEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_depthEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11DepthStencilState_depthEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_depthEnable_get" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  result = (bool) ((arg1)->depthEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_depthFunction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_depthFunction_set" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11DepthStencilState_depthFunction_set" "', argument " "2"" of type '" "CompareFunction""'");
  } 
  arg2 = static_cast< CompareFunction >(val2);
  if (arg1) (arg1)->depthFunction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_depthFunction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompareFunction result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11DepthStencilState_depthFunction_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_depthFunction_get" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  result = (CompareFunction) ((arg1)->depthFunction);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CompareFunction->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_depthWrites_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_depthWrites_set" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11DepthStencilState_depthWrites_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthWrites = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_depthWrites_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11DepthStencilState_depthWrites_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_depthWrites_get" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  result = (bool) ((arg1)->depthWrites);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_stencilEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_stencilEnable_set" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11DepthStencilState_stencilEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->stencilEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_stencilEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11DepthStencilState_stencilEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_stencilEnable_get" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  result = (bool) ((arg1)->stencilEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_frontFace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  StencilFace *arg2 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_frontFace_set" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11DepthStencilState_frontFace_set" "', argument " "2"" of type '" "StencilFace *""'"); 
  }
  arg2 = reinterpret_cast< StencilFace * >(argp2);
  if (arg1) (arg1)->frontFace = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_frontFace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StencilFace *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11DepthStencilState_frontFace_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_frontFace_get" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  result = (StencilFace *)& ((arg1)->frontFace);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StencilFace, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_backFace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  StencilFace *arg2 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_backFace_set" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11DepthStencilState_backFace_set" "', argument " "2"" of type '" "StencilFace *""'"); 
  }
  arg2 = reinterpret_cast< StencilFace * >(argp2);
  if (arg1) (arg1)->backFace = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11DepthStencilState_backFace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StencilFace *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11DepthStencilState_backFace_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11DepthStencilState_backFace_get" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  result = (StencilFace *)& ((arg1)->backFace);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StencilFace, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11DepthStencilState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::DepthStencilState *arg1 = (D3D11Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11DepthStencilState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__DepthStencilState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11DepthStencilState" "', argument " "1"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11DepthStencilState) /* defines _wrap_delete_D3D11DepthStencilState_destructor_closure */

SWIGINTERN int _wrap_new_D3D11BlendState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D11Pipe::BlendState *)new D3D11Pipe::BlendState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__BlendState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11BlendState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D11Pipe::BlendState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D11Pipe__BlendState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D11BlendState" "', argument " "1"" of type '" "D3D11Pipe::BlendState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D11BlendState" "', argument " "1"" of type '" "D3D11Pipe::BlendState const &""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  result = (D3D11Pipe::BlendState *)new D3D11Pipe::BlendState((D3D11Pipe::BlendState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__BlendState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11BlendState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D11BlendState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D11BlendState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D11BlendState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D11BlendState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D11Pipe::BlendState::BlendState()\n"
    "    D3D11Pipe::BlendState::BlendState(D3D11Pipe::BlendState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D11BlendState_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = (D3D11Pipe::BlendState *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11BlendState_resourceId_set" "', argument " "1"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11BlendState_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11BlendState_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = (D3D11Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11BlendState_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11BlendState_resourceId_get" "', argument " "1"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11BlendState_alphaToCoverage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = (D3D11Pipe::BlendState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11BlendState_alphaToCoverage_set" "', argument " "1"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11BlendState_alphaToCoverage_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->alphaToCoverage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11BlendState_alphaToCoverage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = (D3D11Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11BlendState_alphaToCoverage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11BlendState_alphaToCoverage_get" "', argument " "1"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  result = (bool) ((arg1)->alphaToCoverage);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11BlendState_independentBlend_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = (D3D11Pipe::BlendState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11BlendState_independentBlend_set" "', argument " "1"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11BlendState_independentBlend_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->independentBlend = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11BlendState_independentBlend_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = (D3D11Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11BlendState_independentBlend_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11BlendState_independentBlend_get" "', argument " "1"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  result = (bool) ((arg1)->independentBlend);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11BlendState_blends_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = (D3D11Pipe::BlendState *) 0 ;
  rdcarray< ColorBlend > *arg2 = (rdcarray< ColorBlend > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11BlendState_blends_set" "', argument " "1"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D11BlendState_blends_set' argument 2 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D11BlendState_blends_set' argument 2 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->blends = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11BlendState_blends_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = (D3D11Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ColorBlend > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11BlendState_blends_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11BlendState_blends_get" "', argument " "1"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  result = (rdcarray< ColorBlend > *)& ((arg1)->blends);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ColorBlend_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11BlendState_blendFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = (D3D11Pipe::BlendState *) 0 ;
  rdcfixedarray< float,4 > *arg2 = (rdcfixedarray< float,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11BlendState_blendFactor_set" "', argument " "1"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D11BlendState_blendFactor_set' argument 2 of type 'rdcfixedarray< float,4 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D11BlendState_blendFactor_set' argument 2 of type 'rdcfixedarray< float,4 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->blendFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11BlendState_blendFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = (D3D11Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< float,4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11BlendState_blendFactor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11BlendState_blendFactor_get" "', argument " "1"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  result = (rdcfixedarray< float,4 > *)& ((arg1)->blendFactor);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11BlendState_sampleMask_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = (D3D11Pipe::BlendState *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11BlendState_sampleMask_set" "', argument " "1"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11BlendState_sampleMask_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sampleMask = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11BlendState_sampleMask_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = (D3D11Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11BlendState_sampleMask_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11BlendState_sampleMask_get" "', argument " "1"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  result = (uint32_t) ((arg1)->sampleMask);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11BlendState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::BlendState *arg1 = (D3D11Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11BlendState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__BlendState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11BlendState" "', argument " "1"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::BlendState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11BlendState) /* defines _wrap_delete_D3D11BlendState_destructor_closure */

SWIGINTERN int _wrap_new_D3D11OutputMerger__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D11Pipe::OutputMerger *)new D3D11Pipe::OutputMerger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__OutputMerger, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11OutputMerger__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D11Pipe::OutputMerger *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D11Pipe__OutputMerger,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D11OutputMerger" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D11OutputMerger" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger const &""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  result = (D3D11Pipe::OutputMerger *)new D3D11Pipe::OutputMerger((D3D11Pipe::OutputMerger const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__OutputMerger, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11OutputMerger(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D11OutputMerger",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D11OutputMerger__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D11OutputMerger__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D11OutputMerger'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D11Pipe::OutputMerger::OutputMerger()\n"
    "    D3D11Pipe::OutputMerger::OutputMerger(D3D11Pipe::OutputMerger const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_depthStencilState_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  D3D11Pipe::DepthStencilState *arg2 = (D3D11Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_depthStencilState_set" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11OutputMerger_depthStencilState_set" "', argument " "2"" of type '" "D3D11Pipe::DepthStencilState *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::DepthStencilState * >(argp2);
  if (arg1) (arg1)->depthStencilState = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_depthStencilState_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::DepthStencilState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11OutputMerger_depthStencilState_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_depthStencilState_get" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  result = (D3D11Pipe::DepthStencilState *)& ((arg1)->depthStencilState);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__DepthStencilState, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_blendState_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  D3D11Pipe::BlendState *arg2 = (D3D11Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_blendState_set" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11OutputMerger_blendState_set" "', argument " "2"" of type '" "D3D11Pipe::BlendState *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::BlendState * >(argp2);
  if (arg1) (arg1)->blendState = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_blendState_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::BlendState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11OutputMerger_blendState_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_blendState_get" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  result = (D3D11Pipe::BlendState *)& ((arg1)->blendState);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__BlendState, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_renderTargets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  rdcarray< Descriptor > *arg2 = (rdcarray< Descriptor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_renderTargets_set" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D11OutputMerger_renderTargets_set' argument 2 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D11OutputMerger_renderTargets_set' argument 2 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->renderTargets = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_renderTargets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< Descriptor > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11OutputMerger_renderTargets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_renderTargets_get" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  result = (rdcarray< Descriptor > *)& ((arg1)->renderTargets);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_Descriptor_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_uavStartSlot_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_uavStartSlot_set" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11OutputMerger_uavStartSlot_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->uavStartSlot = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_uavStartSlot_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11OutputMerger_uavStartSlot_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_uavStartSlot_get" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  result = (uint32_t) ((arg1)->uavStartSlot);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_depthTarget_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  Descriptor *arg2 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_depthTarget_set" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11OutputMerger_depthTarget_set" "', argument " "2"" of type '" "Descriptor *""'"); 
  }
  arg2 = reinterpret_cast< Descriptor * >(argp2);
  if (arg1) (arg1)->depthTarget = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_depthTarget_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Descriptor *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11OutputMerger_depthTarget_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_depthTarget_get" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  result = (Descriptor *)& ((arg1)->depthTarget);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Descriptor, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_depthReadOnly_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_depthReadOnly_set" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11OutputMerger_depthReadOnly_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthReadOnly = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_depthReadOnly_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11OutputMerger_depthReadOnly_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_depthReadOnly_get" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  result = (bool) ((arg1)->depthReadOnly);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_stencilReadOnly_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_stencilReadOnly_set" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11OutputMerger_stencilReadOnly_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->stencilReadOnly = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11OutputMerger_stencilReadOnly_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11OutputMerger_stencilReadOnly_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11OutputMerger_stencilReadOnly_get" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  result = (bool) ((arg1)->stencilReadOnly);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11OutputMerger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::OutputMerger *arg1 = (D3D11Pipe::OutputMerger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11OutputMerger",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__OutputMerger, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11OutputMerger" "', argument " "1"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11OutputMerger) /* defines _wrap_delete_D3D11OutputMerger_destructor_closure */

SWIGINTERN int _wrap_new_D3D11Predication__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D11Pipe::Predication *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D11Pipe::Predication *)new D3D11Pipe::Predication();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Predication, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11Predication__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D11Pipe::Predication *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D11Pipe::Predication *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D11Pipe__Predication,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D11Predication" "', argument " "1"" of type '" "D3D11Pipe::Predication const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D11Predication" "', argument " "1"" of type '" "D3D11Pipe::Predication const &""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Predication * >(argp1);
  result = (D3D11Pipe::Predication *)new D3D11Pipe::Predication((D3D11Pipe::Predication const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Predication, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D11Predication(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D11Predication",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D11Predication__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D11Predication__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D11Predication'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D11Pipe::Predication::Predication()\n"
    "    D3D11Pipe::Predication::Predication(D3D11Pipe::Predication const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D11Predication_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Predication *arg1 = (D3D11Pipe::Predication *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Predication_resourceId_set" "', argument " "1"" of type '" "D3D11Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Predication * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11Predication_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Predication_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Predication *arg1 = (D3D11Pipe::Predication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Predication_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Predication_resourceId_get" "', argument " "1"" of type '" "D3D11Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Predication * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Predication_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Predication *arg1 = (D3D11Pipe::Predication *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Predication_value_set" "', argument " "1"" of type '" "D3D11Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Predication * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11Predication_value_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Predication_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Predication *arg1 = (D3D11Pipe::Predication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Predication_value_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Predication_value_get" "', argument " "1"" of type '" "D3D11Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Predication * >(argp1);
  result = (bool) ((arg1)->value);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Predication_isPassing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Predication *arg1 = (D3D11Pipe::Predication *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Predication_isPassing_set" "', argument " "1"" of type '" "D3D11Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Predication * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11Predication_isPassing_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isPassing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11Predication_isPassing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Predication *arg1 = (D3D11Pipe::Predication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11Predication_isPassing_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11Predication_isPassing_get" "', argument " "1"" of type '" "D3D11Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Predication * >(argp1);
  result = (bool) ((arg1)->isPassing);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11Predication(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::Predication *arg1 = (D3D11Pipe::Predication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11Predication",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__Predication, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11Predication" "', argument " "1"" of type '" "D3D11Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::Predication * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11Predication) /* defines _wrap_delete_D3D11Predication_destructor_closure */

SWIGINTERN PyObject *_wrap_D3D11State_inputAssembly_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  D3D11Pipe::InputAssembly *arg2 = (D3D11Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_inputAssembly_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11State_inputAssembly_set" "', argument " "2"" of type '" "D3D11Pipe::InputAssembly *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::InputAssembly * >(argp2);
  if (arg1) (arg1)->inputAssembly = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_inputAssembly_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::InputAssembly *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_inputAssembly_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_inputAssembly_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (D3D11Pipe::InputAssembly *)& ((arg1)->inputAssembly);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__InputAssembly, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_vertexShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  D3D11Pipe::Shader *arg2 = (D3D11Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_vertexShader_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11State_vertexShader_set" "', argument " "2"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::Shader * >(argp2);
  if (arg1) (arg1)->vertexShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_vertexShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_vertexShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_vertexShader_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (D3D11Pipe::Shader *)& ((arg1)->vertexShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_hullShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  D3D11Pipe::Shader *arg2 = (D3D11Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_hullShader_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11State_hullShader_set" "', argument " "2"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::Shader * >(argp2);
  if (arg1) (arg1)->hullShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_hullShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_hullShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_hullShader_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (D3D11Pipe::Shader *)& ((arg1)->hullShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_domainShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  D3D11Pipe::Shader *arg2 = (D3D11Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_domainShader_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11State_domainShader_set" "', argument " "2"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::Shader * >(argp2);
  if (arg1) (arg1)->domainShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_domainShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_domainShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_domainShader_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (D3D11Pipe::Shader *)& ((arg1)->domainShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_geometryShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  D3D11Pipe::Shader *arg2 = (D3D11Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_geometryShader_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11State_geometryShader_set" "', argument " "2"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::Shader * >(argp2);
  if (arg1) (arg1)->geometryShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_geometryShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_geometryShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_geometryShader_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (D3D11Pipe::Shader *)& ((arg1)->geometryShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_pixelShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  D3D11Pipe::Shader *arg2 = (D3D11Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_pixelShader_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11State_pixelShader_set" "', argument " "2"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::Shader * >(argp2);
  if (arg1) (arg1)->pixelShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_pixelShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_pixelShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_pixelShader_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (D3D11Pipe::Shader *)& ((arg1)->pixelShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_computeShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  D3D11Pipe::Shader *arg2 = (D3D11Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_computeShader_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11State_computeShader_set" "', argument " "2"" of type '" "D3D11Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::Shader * >(argp2);
  if (arg1) (arg1)->computeShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_computeShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_computeShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_computeShader_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (D3D11Pipe::Shader *)& ((arg1)->computeShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_descriptorStore_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_descriptorStore_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11State_descriptorStore_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->descriptorStore = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_descriptorStore_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_descriptorStore_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_descriptorStore_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (ResourceId *)& ((arg1)->descriptorStore);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_descriptorCount_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_descriptorCount_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11State_descriptorCount_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->descriptorCount = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_descriptorCount_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_descriptorCount_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_descriptorCount_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (uint32_t) ((arg1)->descriptorCount);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_descriptorByteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_descriptorByteSize_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D11State_descriptorByteSize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->descriptorByteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_descriptorByteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_descriptorByteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_descriptorByteSize_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (uint32_t) ((arg1)->descriptorByteSize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_streamOut_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  D3D11Pipe::StreamOut *arg2 = (D3D11Pipe::StreamOut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_streamOut_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__StreamOut, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11State_streamOut_set" "', argument " "2"" of type '" "D3D11Pipe::StreamOut *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::StreamOut * >(argp2);
  if (arg1) (arg1)->streamOut = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_streamOut_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::StreamOut *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_streamOut_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_streamOut_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (D3D11Pipe::StreamOut *)& ((arg1)->streamOut);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__StreamOut, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_rasterizer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  D3D11Pipe::Rasterizer *arg2 = (D3D11Pipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_rasterizer_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11State_rasterizer_set" "', argument " "2"" of type '" "D3D11Pipe::Rasterizer *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::Rasterizer * >(argp2);
  if (arg1) (arg1)->rasterizer = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_rasterizer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::Rasterizer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_rasterizer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_rasterizer_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (D3D11Pipe::Rasterizer *)& ((arg1)->rasterizer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Rasterizer, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_outputMerger_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  D3D11Pipe::OutputMerger *arg2 = (D3D11Pipe::OutputMerger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_outputMerger_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11State_outputMerger_set" "', argument " "2"" of type '" "D3D11Pipe::OutputMerger *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::OutputMerger * >(argp2);
  if (arg1) (arg1)->outputMerger = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_outputMerger_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::OutputMerger *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_outputMerger_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_outputMerger_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (D3D11Pipe::OutputMerger *)& ((arg1)->outputMerger);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__OutputMerger, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_predication_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  D3D11Pipe::Predication *arg2 = (D3D11Pipe::Predication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_predication_set" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D11Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D11State_predication_set" "', argument " "2"" of type '" "D3D11Pipe::Predication *""'"); 
  }
  arg2 = reinterpret_cast< D3D11Pipe::Predication * >(argp2);
  if (arg1) (arg1)->predication = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D11State_predication_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D11Pipe::Predication *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D11State_predication_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D11State_predication_get" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  result = (D3D11Pipe::Predication *)& ((arg1)->predication);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D11Pipe__Predication, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D11State(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D11Pipe::State *arg1 = (D3D11Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D11State",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D11Pipe__State, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D11State" "', argument " "1"" of type '" "D3D11Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D11Pipe::State * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D11State) /* defines _wrap_delete_D3D11State_destructor_closure */

SWIGINTERN int _wrap_new_D3D12Layout__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::Layout *)new D3D12Pipe::Layout();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Layout, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12Layout__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::Layout *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__Layout,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12Layout" "', argument " "1"" of type '" "D3D12Pipe::Layout const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12Layout" "', argument " "1"" of type '" "D3D12Pipe::Layout const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  result = (D3D12Pipe::Layout *)new D3D12Pipe::Layout((D3D12Pipe::Layout const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Layout, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12Layout(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12Layout",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12Layout__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12Layout__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12Layout'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::Layout::Layout()\n"
    "    D3D12Pipe::Layout::Layout(D3D12Pipe::Layout const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12Layout___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  D3D12Pipe::Layout *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout___eq__" "', argument " "1"" of type '" "D3D12Pipe::Layout const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__Layout,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12Layout___eq__" "', argument " "2"" of type '" "D3D12Pipe::Layout const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12Layout___eq__" "', argument " "2"" of type '" "D3D12Pipe::Layout const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::Layout * >(argp2);
  result = (bool)((D3D12Pipe::Layout const *)arg1)->operator ==((D3D12Pipe::Layout const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  D3D12Pipe::Layout *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout___lt__" "', argument " "1"" of type '" "D3D12Pipe::Layout const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__Layout,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12Layout___lt__" "', argument " "2"" of type '" "D3D12Pipe::Layout const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12Layout___lt__" "', argument " "2"" of type '" "D3D12Pipe::Layout const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::Layout * >(argp2);
  result = (bool)((D3D12Pipe::Layout const *)arg1)->operator <((D3D12Pipe::Layout const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_semanticName_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_semanticName_set" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12Layout_semanticName_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->semanticName = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_semanticName_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Layout_semanticName_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_semanticName_get" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  result =  ((arg1)->semanticName);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_semanticIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_semanticIndex_set" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12Layout_semanticIndex_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->semanticIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_semanticIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Layout_semanticIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_semanticIndex_get" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  result = (uint32_t) ((arg1)->semanticIndex);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_format_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  ResourceFormat *arg2 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_format_set" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12Layout_format_set" "', argument " "2"" of type '" "ResourceFormat *""'"); 
  }
  arg2 = reinterpret_cast< ResourceFormat * >(argp2);
  if (arg1) (arg1)->format = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_format_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceFormat *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Layout_format_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_format_get" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  result = (ResourceFormat *)& ((arg1)->format);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_inputSlot_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_inputSlot_set" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12Layout_inputSlot_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->inputSlot = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_inputSlot_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Layout_inputSlot_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_inputSlot_get" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  result = (uint32_t) ((arg1)->inputSlot);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_byteOffset_set" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12Layout_byteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Layout_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_byteOffset_get" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  result = (uint32_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_perInstance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_perInstance_set" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12Layout_perInstance_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->perInstance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_perInstance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Layout_perInstance_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_perInstance_get" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  result = (bool) ((arg1)->perInstance);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_instanceDataStepRate_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_instanceDataStepRate_set" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12Layout_instanceDataStepRate_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->instanceDataStepRate = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Layout_instanceDataStepRate_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Layout_instanceDataStepRate_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Layout_instanceDataStepRate_get" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  result = (uint32_t) ((arg1)->instanceDataStepRate);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12Layout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Layout *arg1 = (D3D12Pipe::Layout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12Layout",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Layout, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12Layout" "', argument " "1"" of type '" "D3D12Pipe::Layout *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Layout * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12Layout) /* defines _wrap_delete_D3D12Layout_destructor_closure */

SWIGINTERN int _wrap_new_D3D12VertexBuffer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::VertexBuffer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::VertexBuffer *)new D3D12Pipe::VertexBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__VertexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12VertexBuffer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::VertexBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::VertexBuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12VertexBuffer" "', argument " "1"" of type '" "D3D12Pipe::VertexBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12VertexBuffer" "', argument " "1"" of type '" "D3D12Pipe::VertexBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp1);
  result = (D3D12Pipe::VertexBuffer *)new D3D12Pipe::VertexBuffer((D3D12Pipe::VertexBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__VertexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12VertexBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12VertexBuffer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12VertexBuffer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12VertexBuffer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12VertexBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::VertexBuffer::VertexBuffer()\n"
    "    D3D12Pipe::VertexBuffer::VertexBuffer(D3D12Pipe::VertexBuffer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12VertexBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::VertexBuffer *arg1 = (D3D12Pipe::VertexBuffer *) 0 ;
  D3D12Pipe::VertexBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12VertexBuffer___eq__" "', argument " "1"" of type '" "D3D12Pipe::VertexBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12VertexBuffer___eq__" "', argument " "2"" of type '" "D3D12Pipe::VertexBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12VertexBuffer___eq__" "', argument " "2"" of type '" "D3D12Pipe::VertexBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp2);
  result = (bool)((D3D12Pipe::VertexBuffer const *)arg1)->operator ==((D3D12Pipe::VertexBuffer const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12VertexBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::VertexBuffer *arg1 = (D3D12Pipe::VertexBuffer *) 0 ;
  D3D12Pipe::VertexBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12VertexBuffer___lt__" "', argument " "1"" of type '" "D3D12Pipe::VertexBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12VertexBuffer___lt__" "', argument " "2"" of type '" "D3D12Pipe::VertexBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12VertexBuffer___lt__" "', argument " "2"" of type '" "D3D12Pipe::VertexBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp2);
  result = (bool)((D3D12Pipe::VertexBuffer const *)arg1)->operator <((D3D12Pipe::VertexBuffer const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12VertexBuffer_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::VertexBuffer *arg1 = (D3D12Pipe::VertexBuffer *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12VertexBuffer_resourceId_set" "', argument " "1"" of type '" "D3D12Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12VertexBuffer_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12VertexBuffer_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::VertexBuffer *arg1 = (D3D12Pipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12VertexBuffer_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12VertexBuffer_resourceId_get" "', argument " "1"" of type '" "D3D12Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12VertexBuffer_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::VertexBuffer *arg1 = (D3D12Pipe::VertexBuffer *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12VertexBuffer_byteOffset_set" "', argument " "1"" of type '" "D3D12Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12VertexBuffer_byteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12VertexBuffer_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::VertexBuffer *arg1 = (D3D12Pipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12VertexBuffer_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12VertexBuffer_byteOffset_get" "', argument " "1"" of type '" "D3D12Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp1);
  result = (uint64_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12VertexBuffer_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::VertexBuffer *arg1 = (D3D12Pipe::VertexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12VertexBuffer_byteSize_set" "', argument " "1"" of type '" "D3D12Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12VertexBuffer_byteSize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12VertexBuffer_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::VertexBuffer *arg1 = (D3D12Pipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12VertexBuffer_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12VertexBuffer_byteSize_get" "', argument " "1"" of type '" "D3D12Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12VertexBuffer_byteStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::VertexBuffer *arg1 = (D3D12Pipe::VertexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12VertexBuffer_byteStride_set" "', argument " "1"" of type '" "D3D12Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12VertexBuffer_byteStride_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12VertexBuffer_byteStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::VertexBuffer *arg1 = (D3D12Pipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12VertexBuffer_byteStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12VertexBuffer_byteStride_get" "', argument " "1"" of type '" "D3D12Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteStride);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12VertexBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::VertexBuffer *arg1 = (D3D12Pipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12VertexBuffer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__VertexBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12VertexBuffer" "', argument " "1"" of type '" "D3D12Pipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12VertexBuffer) /* defines _wrap_delete_D3D12VertexBuffer_destructor_closure */

SWIGINTERN int _wrap_new_D3D12IndexBuffer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::IndexBuffer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::IndexBuffer *)new D3D12Pipe::IndexBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__IndexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12IndexBuffer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::IndexBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::IndexBuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__IndexBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12IndexBuffer" "', argument " "1"" of type '" "D3D12Pipe::IndexBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12IndexBuffer" "', argument " "1"" of type '" "D3D12Pipe::IndexBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::IndexBuffer * >(argp1);
  result = (D3D12Pipe::IndexBuffer *)new D3D12Pipe::IndexBuffer((D3D12Pipe::IndexBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__IndexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12IndexBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12IndexBuffer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12IndexBuffer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12IndexBuffer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12IndexBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::IndexBuffer::IndexBuffer()\n"
    "    D3D12Pipe::IndexBuffer::IndexBuffer(D3D12Pipe::IndexBuffer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12IndexBuffer_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::IndexBuffer *arg1 = (D3D12Pipe::IndexBuffer *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12IndexBuffer_resourceId_set" "', argument " "1"" of type '" "D3D12Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::IndexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12IndexBuffer_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12IndexBuffer_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::IndexBuffer *arg1 = (D3D12Pipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12IndexBuffer_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12IndexBuffer_resourceId_get" "', argument " "1"" of type '" "D3D12Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::IndexBuffer * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12IndexBuffer_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::IndexBuffer *arg1 = (D3D12Pipe::IndexBuffer *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12IndexBuffer_byteOffset_set" "', argument " "1"" of type '" "D3D12Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::IndexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12IndexBuffer_byteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12IndexBuffer_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::IndexBuffer *arg1 = (D3D12Pipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12IndexBuffer_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12IndexBuffer_byteOffset_get" "', argument " "1"" of type '" "D3D12Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::IndexBuffer * >(argp1);
  result = (uint64_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12IndexBuffer_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::IndexBuffer *arg1 = (D3D12Pipe::IndexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12IndexBuffer_byteSize_set" "', argument " "1"" of type '" "D3D12Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::IndexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12IndexBuffer_byteSize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12IndexBuffer_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::IndexBuffer *arg1 = (D3D12Pipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12IndexBuffer_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12IndexBuffer_byteSize_get" "', argument " "1"" of type '" "D3D12Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::IndexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12IndexBuffer_byteStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::IndexBuffer *arg1 = (D3D12Pipe::IndexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12IndexBuffer_byteStride_set" "', argument " "1"" of type '" "D3D12Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::IndexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12IndexBuffer_byteStride_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12IndexBuffer_byteStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::IndexBuffer *arg1 = (D3D12Pipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12IndexBuffer_byteStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12IndexBuffer_byteStride_get" "', argument " "1"" of type '" "D3D12Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::IndexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteStride);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12IndexBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::IndexBuffer *arg1 = (D3D12Pipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12IndexBuffer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__IndexBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12IndexBuffer" "', argument " "1"" of type '" "D3D12Pipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::IndexBuffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12IndexBuffer) /* defines _wrap_delete_D3D12IndexBuffer_destructor_closure */

SWIGINTERN int _wrap_new_D3D12InputAssembly__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::InputAssembly *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::InputAssembly *)new D3D12Pipe::InputAssembly();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__InputAssembly, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12InputAssembly__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::InputAssembly *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::InputAssembly *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__InputAssembly,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12InputAssembly" "', argument " "1"" of type '" "D3D12Pipe::InputAssembly const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12InputAssembly" "', argument " "1"" of type '" "D3D12Pipe::InputAssembly const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::InputAssembly * >(argp1);
  result = (D3D12Pipe::InputAssembly *)new D3D12Pipe::InputAssembly((D3D12Pipe::InputAssembly const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__InputAssembly, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12InputAssembly(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12InputAssembly",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12InputAssembly__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12InputAssembly__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12InputAssembly'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::InputAssembly::InputAssembly()\n"
    "    D3D12Pipe::InputAssembly::InputAssembly(D3D12Pipe::InputAssembly const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12InputAssembly_layouts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::InputAssembly *arg1 = (D3D12Pipe::InputAssembly *) 0 ;
  rdcarray< D3D12Pipe::Layout > *arg2 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12InputAssembly_layouts_set" "', argument " "1"" of type '" "D3D12Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::InputAssembly * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12InputAssembly_layouts_set' argument 2 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12InputAssembly_layouts_set' argument 2 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->layouts = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12InputAssembly_layouts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::InputAssembly *arg1 = (D3D12Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< D3D12Pipe::Layout > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12InputAssembly_layouts_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12InputAssembly_layouts_get" "', argument " "1"" of type '" "D3D12Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::InputAssembly * >(argp1);
  result = (rdcarray< D3D12Pipe::Layout > *)& ((arg1)->layouts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_D3D12Pipe__Layout_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12InputAssembly_vertexBuffers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::InputAssembly *arg1 = (D3D12Pipe::InputAssembly *) 0 ;
  rdcarray< D3D12Pipe::VertexBuffer > *arg2 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12InputAssembly_vertexBuffers_set" "', argument " "1"" of type '" "D3D12Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::InputAssembly * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12InputAssembly_vertexBuffers_set' argument 2 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12InputAssembly_vertexBuffers_set' argument 2 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->vertexBuffers = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12InputAssembly_vertexBuffers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::InputAssembly *arg1 = (D3D12Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< D3D12Pipe::VertexBuffer > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12InputAssembly_vertexBuffers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12InputAssembly_vertexBuffers_get" "', argument " "1"" of type '" "D3D12Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::InputAssembly * >(argp1);
  result = (rdcarray< D3D12Pipe::VertexBuffer > *)& ((arg1)->vertexBuffers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_D3D12Pipe__VertexBuffer_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12InputAssembly_indexBuffer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::InputAssembly *arg1 = (D3D12Pipe::InputAssembly *) 0 ;
  D3D12Pipe::IndexBuffer *arg2 = (D3D12Pipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12InputAssembly_indexBuffer_set" "', argument " "1"" of type '" "D3D12Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::InputAssembly * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12InputAssembly_indexBuffer_set" "', argument " "2"" of type '" "D3D12Pipe::IndexBuffer *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::IndexBuffer * >(argp2);
  if (arg1) (arg1)->indexBuffer = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12InputAssembly_indexBuffer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::InputAssembly *arg1 = (D3D12Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::IndexBuffer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12InputAssembly_indexBuffer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12InputAssembly_indexBuffer_get" "', argument " "1"" of type '" "D3D12Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::InputAssembly * >(argp1);
  result = (D3D12Pipe::IndexBuffer *)& ((arg1)->indexBuffer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__IndexBuffer, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12InputAssembly_indexStripCutValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::InputAssembly *arg1 = (D3D12Pipe::InputAssembly *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12InputAssembly_indexStripCutValue_set" "', argument " "1"" of type '" "D3D12Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::InputAssembly * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12InputAssembly_indexStripCutValue_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->indexStripCutValue = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12InputAssembly_indexStripCutValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::InputAssembly *arg1 = (D3D12Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12InputAssembly_indexStripCutValue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12InputAssembly_indexStripCutValue_get" "', argument " "1"" of type '" "D3D12Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::InputAssembly * >(argp1);
  result = (uint32_t) ((arg1)->indexStripCutValue);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12InputAssembly_topology_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::InputAssembly *arg1 = (D3D12Pipe::InputAssembly *) 0 ;
  Topology arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12InputAssembly_topology_set" "', argument " "1"" of type '" "D3D12Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::InputAssembly * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12InputAssembly_topology_set" "', argument " "2"" of type '" "Topology""'");
  } 
  arg2 = static_cast< Topology >(val2);
  if (arg1) (arg1)->topology = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12InputAssembly_topology_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::InputAssembly *arg1 = (D3D12Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Topology result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12InputAssembly_topology_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12InputAssembly_topology_get" "', argument " "1"" of type '" "D3D12Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::InputAssembly * >(argp1);
  result = (Topology) ((arg1)->topology);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_Topology->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12InputAssembly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::InputAssembly *arg1 = (D3D12Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12InputAssembly",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__InputAssembly, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12InputAssembly" "', argument " "1"" of type '" "D3D12Pipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::InputAssembly * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12InputAssembly) /* defines _wrap_delete_D3D12InputAssembly_destructor_closure */

SWIGINTERN int _wrap_new_D3D12Shader__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::Shader *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::Shader *)new D3D12Pipe::Shader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Shader, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12Shader__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::Shader *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::Shader *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__Shader,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12Shader" "', argument " "1"" of type '" "D3D12Pipe::Shader const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12Shader" "', argument " "1"" of type '" "D3D12Pipe::Shader const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Shader * >(argp1);
  result = (D3D12Pipe::Shader *)new D3D12Pipe::Shader((D3D12Pipe::Shader const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Shader, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12Shader(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12Shader",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12Shader__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12Shader__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12Shader'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::Shader::Shader()\n"
    "    D3D12Pipe::Shader::Shader(D3D12Pipe::Shader const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12Shader_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Shader *arg1 = (D3D12Pipe::Shader *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Shader_resourceId_set" "', argument " "1"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Shader * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12Shader_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Shader_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Shader *arg1 = (D3D12Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Shader_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Shader_resourceId_get" "', argument " "1"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Shader * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Shader_reflection_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Shader *arg1 = (D3D12Pipe::Shader *) 0 ;
  ShaderReflection *arg2 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Shader_reflection_set" "', argument " "1"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Shader * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderReflection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12Shader_reflection_set" "', argument " "2"" of type '" "ShaderReflection const *""'"); 
  }
  arg2 = reinterpret_cast< ShaderReflection * >(argp2);
  if (arg1) (arg1)->reflection = (ShaderReflection const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Shader_reflection_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Shader *arg1 = (D3D12Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderReflection *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Shader_reflection_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Shader_reflection_get" "', argument " "1"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Shader * >(argp1);
  result = (ShaderReflection *) ((arg1)->reflection);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Shader_stage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Shader *arg1 = (D3D12Pipe::Shader *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Shader_stage_set" "', argument " "1"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Shader * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12Shader_stage_set" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  if (arg1) (arg1)->stage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Shader_stage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Shader *arg1 = (D3D12Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStage result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Shader_stage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Shader_stage_get" "', argument " "1"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Shader * >(argp1);
  result = (ShaderStage) ((arg1)->stage);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12Shader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Shader *arg1 = (D3D12Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12Shader",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Shader, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12Shader" "', argument " "1"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Shader * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12Shader) /* defines _wrap_delete_D3D12Shader_destructor_closure */

SWIGINTERN int _wrap_new_D3D12StreamOutBind__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::StreamOutBind *)new D3D12Pipe::StreamOutBind();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__StreamOutBind, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12StreamOutBind__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::StreamOutBind *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__StreamOutBind,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12StreamOutBind" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12StreamOutBind" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  result = (D3D12Pipe::StreamOutBind *)new D3D12Pipe::StreamOutBind((D3D12Pipe::StreamOutBind const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__StreamOutBind, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12StreamOutBind(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12StreamOutBind",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12StreamOutBind__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12StreamOutBind__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12StreamOutBind'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::StreamOutBind::StreamOutBind()\n"
    "    D3D12Pipe::StreamOutBind::StreamOutBind(D3D12Pipe::StreamOutBind const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOutBind___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = (D3D12Pipe::StreamOutBind *) 0 ;
  D3D12Pipe::StreamOutBind *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOutBind___eq__" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__StreamOutBind,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12StreamOutBind___eq__" "', argument " "2"" of type '" "D3D12Pipe::StreamOutBind const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12StreamOutBind___eq__" "', argument " "2"" of type '" "D3D12Pipe::StreamOutBind const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp2);
  result = (bool)((D3D12Pipe::StreamOutBind const *)arg1)->operator ==((D3D12Pipe::StreamOutBind const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOutBind___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = (D3D12Pipe::StreamOutBind *) 0 ;
  D3D12Pipe::StreamOutBind *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOutBind___lt__" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__StreamOutBind,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12StreamOutBind___lt__" "', argument " "2"" of type '" "D3D12Pipe::StreamOutBind const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12StreamOutBind___lt__" "', argument " "2"" of type '" "D3D12Pipe::StreamOutBind const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp2);
  result = (bool)((D3D12Pipe::StreamOutBind const *)arg1)->operator <((D3D12Pipe::StreamOutBind const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOutBind_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = (D3D12Pipe::StreamOutBind *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOutBind_resourceId_set" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12StreamOutBind_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOutBind_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = (D3D12Pipe::StreamOutBind *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12StreamOutBind_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOutBind_resourceId_get" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOutBind_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = (D3D12Pipe::StreamOutBind *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOutBind_byteOffset_set" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12StreamOutBind_byteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOutBind_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = (D3D12Pipe::StreamOutBind *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12StreamOutBind_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOutBind_byteOffset_get" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  result = (uint64_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOutBind_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = (D3D12Pipe::StreamOutBind *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOutBind_byteSize_set" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12StreamOutBind_byteSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOutBind_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = (D3D12Pipe::StreamOutBind *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12StreamOutBind_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOutBind_byteSize_get" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  result = (uint64_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOutBind_writtenCountResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = (D3D12Pipe::StreamOutBind *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOutBind_writtenCountResourceId_set" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12StreamOutBind_writtenCountResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->writtenCountResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOutBind_writtenCountResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = (D3D12Pipe::StreamOutBind *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12StreamOutBind_writtenCountResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOutBind_writtenCountResourceId_get" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  result = (ResourceId *)& ((arg1)->writtenCountResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOutBind_writtenCountByteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = (D3D12Pipe::StreamOutBind *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOutBind_writtenCountByteOffset_set" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12StreamOutBind_writtenCountByteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->writtenCountByteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOutBind_writtenCountByteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = (D3D12Pipe::StreamOutBind *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12StreamOutBind_writtenCountByteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOutBind, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOutBind_writtenCountByteOffset_get" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  result = (uint64_t) ((arg1)->writtenCountByteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12StreamOutBind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOutBind *arg1 = (D3D12Pipe::StreamOutBind *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12StreamOutBind",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOutBind, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12StreamOutBind" "', argument " "1"" of type '" "D3D12Pipe::StreamOutBind *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12StreamOutBind) /* defines _wrap_delete_D3D12StreamOutBind_destructor_closure */

SWIGINTERN int _wrap_new_D3D12StreamOut__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOut *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::StreamOut *)new D3D12Pipe::StreamOut();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__StreamOut, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12StreamOut__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOut *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::StreamOut *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__StreamOut,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12StreamOut" "', argument " "1"" of type '" "D3D12Pipe::StreamOut const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12StreamOut" "', argument " "1"" of type '" "D3D12Pipe::StreamOut const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOut * >(argp1);
  result = (D3D12Pipe::StreamOut *)new D3D12Pipe::StreamOut((D3D12Pipe::StreamOut const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__StreamOut, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12StreamOut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12StreamOut",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12StreamOut__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12StreamOut__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12StreamOut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::StreamOut::StreamOut()\n"
    "    D3D12Pipe::StreamOut::StreamOut(D3D12Pipe::StreamOut const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOut_outputs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOut *arg1 = (D3D12Pipe::StreamOut *) 0 ;
  rdcarray< D3D12Pipe::StreamOutBind > *arg2 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOut_outputs_set" "', argument " "1"" of type '" "D3D12Pipe::StreamOut *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOut * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12StreamOut_outputs_set' argument 2 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12StreamOut_outputs_set' argument 2 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->outputs = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOut_outputs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOut *arg1 = (D3D12Pipe::StreamOut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< D3D12Pipe::StreamOutBind > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12StreamOut_outputs_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOut_outputs_get" "', argument " "1"" of type '" "D3D12Pipe::StreamOut *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOut * >(argp1);
  result = (rdcarray< D3D12Pipe::StreamOutBind > *)& ((arg1)->outputs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_D3D12Pipe__StreamOutBind_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOut_rasterizedStream_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOut *arg1 = (D3D12Pipe::StreamOut *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOut_rasterizedStream_set" "', argument " "1"" of type '" "D3D12Pipe::StreamOut *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOut * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12StreamOut_rasterizedStream_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->rasterizedStream = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StreamOut_rasterizedStream_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOut *arg1 = (D3D12Pipe::StreamOut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12StreamOut_rasterizedStream_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StreamOut_rasterizedStream_get" "', argument " "1"" of type '" "D3D12Pipe::StreamOut *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOut * >(argp1);
  result = (uint32_t) ((arg1)->rasterizedStream);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12StreamOut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StreamOut *arg1 = (D3D12Pipe::StreamOut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12StreamOut",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StreamOut, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12StreamOut" "', argument " "1"" of type '" "D3D12Pipe::StreamOut *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StreamOut * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12StreamOut) /* defines _wrap_delete_D3D12StreamOut_destructor_closure */

SWIGINTERN int _wrap_new_D3D12RasterizerState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::RasterizerState *)new D3D12Pipe::RasterizerState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__RasterizerState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12RasterizerState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::RasterizerState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__RasterizerState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12RasterizerState" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12RasterizerState" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result = (D3D12Pipe::RasterizerState *)new D3D12Pipe::RasterizerState((D3D12Pipe::RasterizerState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__RasterizerState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12RasterizerState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12RasterizerState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12RasterizerState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12RasterizerState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12RasterizerState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::RasterizerState::RasterizerState()\n"
    "    D3D12Pipe::RasterizerState::RasterizerState(D3D12Pipe::RasterizerState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_fillMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  FillMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_fillMode_set" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RasterizerState_fillMode_set" "', argument " "2"" of type '" "FillMode""'");
  } 
  arg2 = static_cast< FillMode >(val2);
  if (arg1) (arg1)->fillMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_fillMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FillMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RasterizerState_fillMode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_fillMode_get" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result = (FillMode) ((arg1)->fillMode);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_FillMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_cullMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  CullMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_cullMode_set" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RasterizerState_cullMode_set" "', argument " "2"" of type '" "CullMode""'");
  } 
  arg2 = static_cast< CullMode >(val2);
  if (arg1) (arg1)->cullMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_cullMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CullMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RasterizerState_cullMode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_cullMode_get" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result = (CullMode) ((arg1)->cullMode);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CullMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_frontCCW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_frontCCW_set" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RasterizerState_frontCCW_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->frontCCW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_frontCCW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RasterizerState_frontCCW_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_frontCCW_get" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->frontCCW);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_depthBias_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_depthBias_set" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RasterizerState_depthBias_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->depthBias = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_depthBias_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RasterizerState_depthBias_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_depthBias_get" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result = (float) ((arg1)->depthBias);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_depthBiasClamp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_depthBiasClamp_set" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RasterizerState_depthBiasClamp_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->depthBiasClamp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_depthBiasClamp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RasterizerState_depthBiasClamp_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_depthBiasClamp_get" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result = (float) ((arg1)->depthBiasClamp);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_slopeScaledDepthBias_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_slopeScaledDepthBias_set" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RasterizerState_slopeScaledDepthBias_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->slopeScaledDepthBias = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_slopeScaledDepthBias_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RasterizerState_slopeScaledDepthBias_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_slopeScaledDepthBias_get" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result = (float) ((arg1)->slopeScaledDepthBias);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_depthClip_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_depthClip_set" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RasterizerState_depthClip_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthClip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_depthClip_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RasterizerState_depthClip_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_depthClip_get" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->depthClip);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_lineRasterMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  LineRaster arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_lineRasterMode_set" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RasterizerState_lineRasterMode_set" "', argument " "2"" of type '" "LineRaster""'");
  } 
  arg2 = static_cast< LineRaster >(val2);
  if (arg1) (arg1)->lineRasterMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_lineRasterMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  LineRaster result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RasterizerState_lineRasterMode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_lineRasterMode_get" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result = (LineRaster) ((arg1)->lineRasterMode);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_LineRaster->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_forcedSampleCount_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_forcedSampleCount_set" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RasterizerState_forcedSampleCount_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->forcedSampleCount = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_forcedSampleCount_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RasterizerState_forcedSampleCount_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_forcedSampleCount_get" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result = (uint32_t) ((arg1)->forcedSampleCount);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_conservativeRasterization_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  ConservativeRaster arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_conservativeRasterization_set" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RasterizerState_conservativeRasterization_set" "', argument " "2"" of type '" "ConservativeRaster""'");
  } 
  arg2 = static_cast< ConservativeRaster >(val2);
  if (arg1) (arg1)->conservativeRasterization = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_conservativeRasterization_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConservativeRaster result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RasterizerState_conservativeRasterization_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_conservativeRasterization_get" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result = (ConservativeRaster) ((arg1)->conservativeRasterization);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ConservativeRaster->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_baseShadingRate_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  rdcpair< uint32_t,uint32_t > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_baseShadingRate_set" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_rdcpairT_unsigned_int_unsigned_int_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12RasterizerState_baseShadingRate_set" "', argument " "2"" of type '" "rdcpair< uint32_t,uint32_t >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12RasterizerState_baseShadingRate_set" "', argument " "2"" of type '" "rdcpair< uint32_t,uint32_t >""'");
    } else {
      rdcpair< uint32_t,uint32_t > * temp = reinterpret_cast< rdcpair< uint32_t,uint32_t > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  if (arg1) (arg1)->baseShadingRate = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_baseShadingRate_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcpair< uint32_t,uint32_t > result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RasterizerState_baseShadingRate_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_baseShadingRate_get" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result =  ((arg1)->baseShadingRate);
  {
    resultobj = ConvertToPy((rdcpair< uint32_t,uint32_t >&)result);
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_shadingRateCombiners_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  rdcpair< ShadingRateCombiner,ShadingRateCombiner > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_shadingRateCombiners_set" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_rdcpairT_ShadingRateCombiner_ShadingRateCombiner_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12RasterizerState_shadingRateCombiners_set" "', argument " "2"" of type '" "rdcpair< ShadingRateCombiner,ShadingRateCombiner >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12RasterizerState_shadingRateCombiners_set" "', argument " "2"" of type '" "rdcpair< ShadingRateCombiner,ShadingRateCombiner >""'");
    } else {
      rdcpair< ShadingRateCombiner,ShadingRateCombiner > * temp = reinterpret_cast< rdcpair< ShadingRateCombiner,ShadingRateCombiner > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  if (arg1) (arg1)->shadingRateCombiners = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_shadingRateCombiners_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcpair< ShadingRateCombiner,ShadingRateCombiner > result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RasterizerState_shadingRateCombiners_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_shadingRateCombiners_get" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result =  ((arg1)->shadingRateCombiners);
  {
    resultobj = ConvertToPy((rdcpair< ShadingRateCombiner,ShadingRateCombiner >&)result);
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_shadingRateImage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_shadingRateImage_set" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12RasterizerState_shadingRateImage_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->shadingRateImage = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RasterizerState_shadingRateImage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RasterizerState_shadingRateImage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RasterizerState_shadingRateImage_get" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  result = (ResourceId *)& ((arg1)->shadingRateImage);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12RasterizerState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RasterizerState *arg1 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12RasterizerState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RasterizerState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12RasterizerState" "', argument " "1"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12RasterizerState) /* defines _wrap_delete_D3D12RasterizerState_destructor_closure */

SWIGINTERN int _wrap_new_D3D12Rasterizer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::Rasterizer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::Rasterizer *)new D3D12Pipe::Rasterizer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Rasterizer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12Rasterizer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::Rasterizer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::Rasterizer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__Rasterizer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12Rasterizer" "', argument " "1"" of type '" "D3D12Pipe::Rasterizer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12Rasterizer" "', argument " "1"" of type '" "D3D12Pipe::Rasterizer const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Rasterizer * >(argp1);
  result = (D3D12Pipe::Rasterizer *)new D3D12Pipe::Rasterizer((D3D12Pipe::Rasterizer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Rasterizer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12Rasterizer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12Rasterizer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12Rasterizer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12Rasterizer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12Rasterizer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::Rasterizer::Rasterizer()\n"
    "    D3D12Pipe::Rasterizer::Rasterizer(D3D12Pipe::Rasterizer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12Rasterizer_sampleMask_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Rasterizer *arg1 = (D3D12Pipe::Rasterizer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Rasterizer_sampleMask_set" "', argument " "1"" of type '" "D3D12Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12Rasterizer_sampleMask_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sampleMask = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Rasterizer_sampleMask_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Rasterizer *arg1 = (D3D12Pipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Rasterizer_sampleMask_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Rasterizer_sampleMask_get" "', argument " "1"" of type '" "D3D12Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Rasterizer * >(argp1);
  result = (uint32_t) ((arg1)->sampleMask);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Rasterizer_viewports_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Rasterizer *arg1 = (D3D12Pipe::Rasterizer *) 0 ;
  rdcarray< Viewport > *arg2 = (rdcarray< Viewport > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Rasterizer_viewports_set" "', argument " "1"" of type '" "D3D12Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Rasterizer * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12Rasterizer_viewports_set' argument 2 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12Rasterizer_viewports_set' argument 2 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->viewports = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Rasterizer_viewports_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Rasterizer *arg1 = (D3D12Pipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< Viewport > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Rasterizer_viewports_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Rasterizer_viewports_get" "', argument " "1"" of type '" "D3D12Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Rasterizer * >(argp1);
  result = (rdcarray< Viewport > *)& ((arg1)->viewports);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_Viewport_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Rasterizer_scissors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Rasterizer *arg1 = (D3D12Pipe::Rasterizer *) 0 ;
  rdcarray< Scissor > *arg2 = (rdcarray< Scissor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Rasterizer_scissors_set" "', argument " "1"" of type '" "D3D12Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Rasterizer * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12Rasterizer_scissors_set' argument 2 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12Rasterizer_scissors_set' argument 2 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->scissors = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Rasterizer_scissors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Rasterizer *arg1 = (D3D12Pipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< Scissor > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Rasterizer_scissors_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Rasterizer_scissors_get" "', argument " "1"" of type '" "D3D12Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Rasterizer * >(argp1);
  result = (rdcarray< Scissor > *)& ((arg1)->scissors);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_Scissor_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Rasterizer_state_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Rasterizer *arg1 = (D3D12Pipe::Rasterizer *) 0 ;
  D3D12Pipe::RasterizerState *arg2 = (D3D12Pipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Rasterizer_state_set" "', argument " "1"" of type '" "D3D12Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Rasterizer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12Rasterizer_state_set" "', argument " "2"" of type '" "D3D12Pipe::RasterizerState *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::RasterizerState * >(argp2);
  if (arg1) (arg1)->state = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Rasterizer_state_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Rasterizer *arg1 = (D3D12Pipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::RasterizerState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Rasterizer_state_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Rasterizer_state_get" "', argument " "1"" of type '" "D3D12Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Rasterizer * >(argp1);
  result = (D3D12Pipe::RasterizerState *)& ((arg1)->state);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__RasterizerState, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12Rasterizer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Rasterizer *arg1 = (D3D12Pipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12Rasterizer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Rasterizer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12Rasterizer" "', argument " "1"" of type '" "D3D12Pipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Rasterizer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12Rasterizer) /* defines _wrap_delete_D3D12Rasterizer_destructor_closure */

SWIGINTERN int _wrap_new_D3D12DepthStencilState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::DepthStencilState *)new D3D12Pipe::DepthStencilState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__DepthStencilState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12DepthStencilState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::DepthStencilState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__DepthStencilState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12DepthStencilState" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12DepthStencilState" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  result = (D3D12Pipe::DepthStencilState *)new D3D12Pipe::DepthStencilState((D3D12Pipe::DepthStencilState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__DepthStencilState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12DepthStencilState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12DepthStencilState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12DepthStencilState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12DepthStencilState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12DepthStencilState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::DepthStencilState::DepthStencilState()\n"
    "    D3D12Pipe::DepthStencilState::DepthStencilState(D3D12Pipe::DepthStencilState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_depthEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_depthEnable_set" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12DepthStencilState_depthEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_depthEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12DepthStencilState_depthEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_depthEnable_get" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  result = (bool) ((arg1)->depthEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_depthWrites_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_depthWrites_set" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12DepthStencilState_depthWrites_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthWrites = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_depthWrites_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12DepthStencilState_depthWrites_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_depthWrites_get" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  result = (bool) ((arg1)->depthWrites);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_depthBoundsEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_depthBoundsEnable_set" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12DepthStencilState_depthBoundsEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthBoundsEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_depthBoundsEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12DepthStencilState_depthBoundsEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_depthBoundsEnable_get" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  result = (bool) ((arg1)->depthBoundsEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_depthFunction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_depthFunction_set" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12DepthStencilState_depthFunction_set" "', argument " "2"" of type '" "CompareFunction""'");
  } 
  arg2 = static_cast< CompareFunction >(val2);
  if (arg1) (arg1)->depthFunction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_depthFunction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompareFunction result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12DepthStencilState_depthFunction_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_depthFunction_get" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  result = (CompareFunction) ((arg1)->depthFunction);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CompareFunction->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_stencilEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_stencilEnable_set" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12DepthStencilState_stencilEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->stencilEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_stencilEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12DepthStencilState_stencilEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_stencilEnable_get" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  result = (bool) ((arg1)->stencilEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_frontFace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  StencilFace *arg2 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_frontFace_set" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12DepthStencilState_frontFace_set" "', argument " "2"" of type '" "StencilFace *""'"); 
  }
  arg2 = reinterpret_cast< StencilFace * >(argp2);
  if (arg1) (arg1)->frontFace = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_frontFace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StencilFace *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12DepthStencilState_frontFace_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_frontFace_get" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  result = (StencilFace *)& ((arg1)->frontFace);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StencilFace, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_backFace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  StencilFace *arg2 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_backFace_set" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12DepthStencilState_backFace_set" "', argument " "2"" of type '" "StencilFace *""'"); 
  }
  arg2 = reinterpret_cast< StencilFace * >(argp2);
  if (arg1) (arg1)->backFace = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_backFace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StencilFace *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12DepthStencilState_backFace_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_backFace_get" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  result = (StencilFace *)& ((arg1)->backFace);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StencilFace, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_minDepthBounds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_minDepthBounds_set" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12DepthStencilState_minDepthBounds_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->minDepthBounds = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_minDepthBounds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12DepthStencilState_minDepthBounds_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_minDepthBounds_get" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  result = (float) ((arg1)->minDepthBounds);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_maxDepthBounds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_maxDepthBounds_set" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12DepthStencilState_maxDepthBounds_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->maxDepthBounds = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12DepthStencilState_maxDepthBounds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12DepthStencilState_maxDepthBounds_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12DepthStencilState_maxDepthBounds_get" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  result = (float) ((arg1)->maxDepthBounds);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12DepthStencilState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::DepthStencilState *arg1 = (D3D12Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12DepthStencilState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__DepthStencilState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12DepthStencilState" "', argument " "1"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12DepthStencilState) /* defines _wrap_delete_D3D12DepthStencilState_destructor_closure */

SWIGINTERN int _wrap_new_D3D12BlendState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::BlendState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::BlendState *)new D3D12Pipe::BlendState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__BlendState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12BlendState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::BlendState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::BlendState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__BlendState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12BlendState" "', argument " "1"" of type '" "D3D12Pipe::BlendState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12BlendState" "', argument " "1"" of type '" "D3D12Pipe::BlendState const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::BlendState * >(argp1);
  result = (D3D12Pipe::BlendState *)new D3D12Pipe::BlendState((D3D12Pipe::BlendState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__BlendState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12BlendState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12BlendState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12BlendState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12BlendState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12BlendState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::BlendState::BlendState()\n"
    "    D3D12Pipe::BlendState::BlendState(D3D12Pipe::BlendState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12BlendState_alphaToCoverage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::BlendState *arg1 = (D3D12Pipe::BlendState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12BlendState_alphaToCoverage_set" "', argument " "1"" of type '" "D3D12Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::BlendState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12BlendState_alphaToCoverage_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->alphaToCoverage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12BlendState_alphaToCoverage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::BlendState *arg1 = (D3D12Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12BlendState_alphaToCoverage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12BlendState_alphaToCoverage_get" "', argument " "1"" of type '" "D3D12Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::BlendState * >(argp1);
  result = (bool) ((arg1)->alphaToCoverage);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12BlendState_independentBlend_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::BlendState *arg1 = (D3D12Pipe::BlendState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12BlendState_independentBlend_set" "', argument " "1"" of type '" "D3D12Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::BlendState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12BlendState_independentBlend_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->independentBlend = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12BlendState_independentBlend_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::BlendState *arg1 = (D3D12Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12BlendState_independentBlend_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12BlendState_independentBlend_get" "', argument " "1"" of type '" "D3D12Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::BlendState * >(argp1);
  result = (bool) ((arg1)->independentBlend);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12BlendState_blends_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::BlendState *arg1 = (D3D12Pipe::BlendState *) 0 ;
  rdcarray< ColorBlend > *arg2 = (rdcarray< ColorBlend > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12BlendState_blends_set" "', argument " "1"" of type '" "D3D12Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::BlendState * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12BlendState_blends_set' argument 2 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12BlendState_blends_set' argument 2 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->blends = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12BlendState_blends_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::BlendState *arg1 = (D3D12Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ColorBlend > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12BlendState_blends_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12BlendState_blends_get" "', argument " "1"" of type '" "D3D12Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::BlendState * >(argp1);
  result = (rdcarray< ColorBlend > *)& ((arg1)->blends);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ColorBlend_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12BlendState_blendFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::BlendState *arg1 = (D3D12Pipe::BlendState *) 0 ;
  rdcfixedarray< float,4 > *arg2 = (rdcfixedarray< float,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12BlendState_blendFactor_set" "', argument " "1"" of type '" "D3D12Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::BlendState * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12BlendState_blendFactor_set' argument 2 of type 'rdcfixedarray< float,4 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12BlendState_blendFactor_set' argument 2 of type 'rdcfixedarray< float,4 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->blendFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12BlendState_blendFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::BlendState *arg1 = (D3D12Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< float,4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12BlendState_blendFactor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12BlendState_blendFactor_get" "', argument " "1"" of type '" "D3D12Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::BlendState * >(argp1);
  result = (rdcfixedarray< float,4 > *)& ((arg1)->blendFactor);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12BlendState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::BlendState *arg1 = (D3D12Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12BlendState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__BlendState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12BlendState" "', argument " "1"" of type '" "D3D12Pipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::BlendState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12BlendState) /* defines _wrap_delete_D3D12BlendState_destructor_closure */

SWIGINTERN int _wrap_new_D3D12OM__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::OM *)new D3D12Pipe::OM();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__OM, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12OM__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::OM *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__OM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12OM" "', argument " "1"" of type '" "D3D12Pipe::OM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12OM" "', argument " "1"" of type '" "D3D12Pipe::OM const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  result = (D3D12Pipe::OM *)new D3D12Pipe::OM((D3D12Pipe::OM const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__OM, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12OM(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12OM",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12OM__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12OM__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12OM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::OM::OM()\n"
    "    D3D12Pipe::OM::OM(D3D12Pipe::OM const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12OM_depthStencilState_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = (D3D12Pipe::OM *) 0 ;
  D3D12Pipe::DepthStencilState *arg2 = (D3D12Pipe::DepthStencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12OM_depthStencilState_set" "', argument " "1"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12OM_depthStencilState_set" "', argument " "2"" of type '" "D3D12Pipe::DepthStencilState *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::DepthStencilState * >(argp2);
  if (arg1) (arg1)->depthStencilState = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12OM_depthStencilState_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = (D3D12Pipe::OM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::DepthStencilState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12OM_depthStencilState_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12OM_depthStencilState_get" "', argument " "1"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  result = (D3D12Pipe::DepthStencilState *)& ((arg1)->depthStencilState);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__DepthStencilState, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12OM_blendState_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = (D3D12Pipe::OM *) 0 ;
  D3D12Pipe::BlendState *arg2 = (D3D12Pipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12OM_blendState_set" "', argument " "1"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12OM_blendState_set" "', argument " "2"" of type '" "D3D12Pipe::BlendState *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::BlendState * >(argp2);
  if (arg1) (arg1)->blendState = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12OM_blendState_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = (D3D12Pipe::OM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::BlendState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12OM_blendState_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12OM_blendState_get" "', argument " "1"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  result = (D3D12Pipe::BlendState *)& ((arg1)->blendState);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__BlendState, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12OM_renderTargets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = (D3D12Pipe::OM *) 0 ;
  rdcarray< Descriptor > *arg2 = (rdcarray< Descriptor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12OM_renderTargets_set" "', argument " "1"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12OM_renderTargets_set' argument 2 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12OM_renderTargets_set' argument 2 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->renderTargets = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12OM_renderTargets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = (D3D12Pipe::OM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< Descriptor > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12OM_renderTargets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12OM_renderTargets_get" "', argument " "1"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  result = (rdcarray< Descriptor > *)& ((arg1)->renderTargets);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_Descriptor_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12OM_depthTarget_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = (D3D12Pipe::OM *) 0 ;
  Descriptor *arg2 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12OM_depthTarget_set" "', argument " "1"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12OM_depthTarget_set" "', argument " "2"" of type '" "Descriptor *""'"); 
  }
  arg2 = reinterpret_cast< Descriptor * >(argp2);
  if (arg1) (arg1)->depthTarget = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12OM_depthTarget_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = (D3D12Pipe::OM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Descriptor *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12OM_depthTarget_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12OM_depthTarget_get" "', argument " "1"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  result = (Descriptor *)& ((arg1)->depthTarget);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Descriptor, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12OM_depthReadOnly_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = (D3D12Pipe::OM *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12OM_depthReadOnly_set" "', argument " "1"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12OM_depthReadOnly_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthReadOnly = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12OM_depthReadOnly_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = (D3D12Pipe::OM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12OM_depthReadOnly_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12OM_depthReadOnly_get" "', argument " "1"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  result = (bool) ((arg1)->depthReadOnly);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12OM_stencilReadOnly_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = (D3D12Pipe::OM *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12OM_stencilReadOnly_set" "', argument " "1"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12OM_stencilReadOnly_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->stencilReadOnly = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12OM_stencilReadOnly_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = (D3D12Pipe::OM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12OM_stencilReadOnly_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12OM_stencilReadOnly_get" "', argument " "1"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  result = (bool) ((arg1)->stencilReadOnly);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12OM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::OM *arg1 = (D3D12Pipe::OM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12OM",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__OM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12OM" "', argument " "1"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::OM * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12OM) /* defines _wrap_delete_D3D12OM_destructor_closure */

SWIGINTERN int _wrap_new_D3D12ResourceState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::ResourceState *)new D3D12Pipe::ResourceState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__ResourceState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12ResourceState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::ResourceState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__ResourceState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12ResourceState" "', argument " "1"" of type '" "D3D12Pipe::ResourceState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12ResourceState" "', argument " "1"" of type '" "D3D12Pipe::ResourceState const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceState * >(argp1);
  result = (D3D12Pipe::ResourceState *)new D3D12Pipe::ResourceState((D3D12Pipe::ResourceState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__ResourceState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12ResourceState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12ResourceState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12ResourceState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12ResourceState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12ResourceState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::ResourceState::ResourceState()\n"
    "    D3D12Pipe::ResourceState::ResourceState(D3D12Pipe::ResourceState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12ResourceState___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceState *arg1 = (D3D12Pipe::ResourceState *) 0 ;
  D3D12Pipe::ResourceState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__ResourceState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12ResourceState___eq__" "', argument " "1"" of type '" "D3D12Pipe::ResourceState const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__ResourceState,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12ResourceState___eq__" "', argument " "2"" of type '" "D3D12Pipe::ResourceState const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12ResourceState___eq__" "', argument " "2"" of type '" "D3D12Pipe::ResourceState const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::ResourceState * >(argp2);
  result = (bool)((D3D12Pipe::ResourceState const *)arg1)->operator ==((D3D12Pipe::ResourceState const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12ResourceState___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceState *arg1 = (D3D12Pipe::ResourceState *) 0 ;
  D3D12Pipe::ResourceState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__ResourceState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12ResourceState___lt__" "', argument " "1"" of type '" "D3D12Pipe::ResourceState const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__ResourceState,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12ResourceState___lt__" "', argument " "2"" of type '" "D3D12Pipe::ResourceState const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12ResourceState___lt__" "', argument " "2"" of type '" "D3D12Pipe::ResourceState const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::ResourceState * >(argp2);
  result = (bool)((D3D12Pipe::ResourceState const *)arg1)->operator <((D3D12Pipe::ResourceState const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12ResourceState_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceState *arg1 = (D3D12Pipe::ResourceState *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__ResourceState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12ResourceState_name_set" "', argument " "1"" of type '" "D3D12Pipe::ResourceState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceState * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12ResourceState_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12ResourceState_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceState *arg1 = (D3D12Pipe::ResourceState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12ResourceState_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__ResourceState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12ResourceState_name_get" "', argument " "1"" of type '" "D3D12Pipe::ResourceState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceState * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12ResourceState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceState *arg1 = (D3D12Pipe::ResourceState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12ResourceState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__ResourceState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12ResourceState" "', argument " "1"" of type '" "D3D12Pipe::ResourceState *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12ResourceState) /* defines _wrap_delete_D3D12ResourceState_destructor_closure */

SWIGINTERN int _wrap_new_D3D12ResourceData__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceData *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::ResourceData *)new D3D12Pipe::ResourceData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__ResourceData, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12ResourceData__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::ResourceData *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__ResourceData,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12ResourceData" "', argument " "1"" of type '" "D3D12Pipe::ResourceData const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12ResourceData" "', argument " "1"" of type '" "D3D12Pipe::ResourceData const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceData * >(argp1);
  result = (D3D12Pipe::ResourceData *)new D3D12Pipe::ResourceData((D3D12Pipe::ResourceData const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__ResourceData, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12ResourceData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12ResourceData",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12ResourceData__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12ResourceData__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12ResourceData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::ResourceData::ResourceData()\n"
    "    D3D12Pipe::ResourceData::ResourceData(D3D12Pipe::ResourceData const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12ResourceData___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceData *arg1 = (D3D12Pipe::ResourceData *) 0 ;
  D3D12Pipe::ResourceData *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__ResourceData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12ResourceData___eq__" "', argument " "1"" of type '" "D3D12Pipe::ResourceData const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__ResourceData,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12ResourceData___eq__" "', argument " "2"" of type '" "D3D12Pipe::ResourceData const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12ResourceData___eq__" "', argument " "2"" of type '" "D3D12Pipe::ResourceData const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::ResourceData * >(argp2);
  result = (bool)((D3D12Pipe::ResourceData const *)arg1)->operator ==((D3D12Pipe::ResourceData const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12ResourceData___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceData *arg1 = (D3D12Pipe::ResourceData *) 0 ;
  D3D12Pipe::ResourceData *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__ResourceData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12ResourceData___lt__" "', argument " "1"" of type '" "D3D12Pipe::ResourceData const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__ResourceData,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12ResourceData___lt__" "', argument " "2"" of type '" "D3D12Pipe::ResourceData const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12ResourceData___lt__" "', argument " "2"" of type '" "D3D12Pipe::ResourceData const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::ResourceData * >(argp2);
  result = (bool)((D3D12Pipe::ResourceData const *)arg1)->operator <((D3D12Pipe::ResourceData const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12ResourceData_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceData *arg1 = (D3D12Pipe::ResourceData *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__ResourceData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12ResourceData_resourceId_set" "', argument " "1"" of type '" "D3D12Pipe::ResourceData *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12ResourceData_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12ResourceData_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceData *arg1 = (D3D12Pipe::ResourceData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12ResourceData_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__ResourceData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12ResourceData_resourceId_get" "', argument " "1"" of type '" "D3D12Pipe::ResourceData *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceData * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12ResourceData_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceData *arg1 = (D3D12Pipe::ResourceData *) 0 ;
  rdcarray< D3D12Pipe::ResourceState > *arg2 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__ResourceData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12ResourceData_states_set" "', argument " "1"" of type '" "D3D12Pipe::ResourceData *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceData * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12ResourceData_states_set' argument 2 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12ResourceData_states_set' argument 2 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->states = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12ResourceData_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceData *arg1 = (D3D12Pipe::ResourceData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< D3D12Pipe::ResourceState > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12ResourceData_states_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__ResourceData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12ResourceData_states_get" "', argument " "1"" of type '" "D3D12Pipe::ResourceData *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceData * >(argp1);
  result = (rdcarray< D3D12Pipe::ResourceState > *)& ((arg1)->states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_D3D12Pipe__ResourceState_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12ResourceData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::ResourceData *arg1 = (D3D12Pipe::ResourceData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12ResourceData",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__ResourceData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12ResourceData" "', argument " "1"" of type '" "D3D12Pipe::ResourceData *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::ResourceData * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12ResourceData) /* defines _wrap_delete_D3D12ResourceData_destructor_closure */

SWIGINTERN int _wrap_new_D3D12RootTableRange__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::RootTableRange *)new D3D12Pipe::RootTableRange();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__RootTableRange, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12RootTableRange__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::RootTableRange *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__RootTableRange,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12RootTableRange" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12RootTableRange" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  result = (D3D12Pipe::RootTableRange *)new D3D12Pipe::RootTableRange((D3D12Pipe::RootTableRange const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__RootTableRange, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12RootTableRange(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12RootTableRange",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12RootTableRange__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12RootTableRange__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12RootTableRange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::RootTableRange::RootTableRange()\n"
    "    D3D12Pipe::RootTableRange::RootTableRange(D3D12Pipe::RootTableRange const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  D3D12Pipe::RootTableRange *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange___eq__" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__RootTableRange,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12RootTableRange___eq__" "', argument " "2"" of type '" "D3D12Pipe::RootTableRange const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12RootTableRange___eq__" "', argument " "2"" of type '" "D3D12Pipe::RootTableRange const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp2);
  result = (bool)((D3D12Pipe::RootTableRange const *)arg1)->operator ==((D3D12Pipe::RootTableRange const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  D3D12Pipe::RootTableRange *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange___lt__" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__RootTableRange,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12RootTableRange___lt__" "', argument " "2"" of type '" "D3D12Pipe::RootTableRange const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12RootTableRange___lt__" "', argument " "2"" of type '" "D3D12Pipe::RootTableRange const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp2);
  result = (bool)((D3D12Pipe::RootTableRange const *)arg1)->operator <((D3D12Pipe::RootTableRange const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange_category_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  DescriptorCategory arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange_category_set" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RootTableRange_category_set" "', argument " "2"" of type '" "DescriptorCategory""'");
  } 
  arg2 = static_cast< DescriptorCategory >(val2);
  if (arg1) (arg1)->category = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange_category_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DescriptorCategory result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootTableRange_category_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange_category_get" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  result = (DescriptorCategory) ((arg1)->category);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_DescriptorCategory->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange_space_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange_space_set" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RootTableRange_space_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->space = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange_space_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootTableRange_space_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange_space_get" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  result = (uint32_t) ((arg1)->space);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange_baseRegister_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange_baseRegister_set" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RootTableRange_baseRegister_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->baseRegister = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange_baseRegister_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootTableRange_baseRegister_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange_baseRegister_get" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  result = (uint32_t) ((arg1)->baseRegister);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange_count_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange_count_set" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RootTableRange_count_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->count = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange_count_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootTableRange_count_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange_count_get" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  result = (uint32_t) ((arg1)->count);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange_tableByteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange_tableByteOffset_set" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RootTableRange_tableByteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->tableByteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange_tableByteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootTableRange_tableByteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange_tableByteOffset_get" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  result = (uint32_t) ((arg1)->tableByteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange_appended_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange_appended_set" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RootTableRange_appended_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->appended = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootTableRange_appended_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootTableRange_appended_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootTableRange_appended_get" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  result = (bool) ((arg1)->appended);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12RootTableRange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootTableRange *arg1 = (D3D12Pipe::RootTableRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12RootTableRange",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootTableRange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12RootTableRange" "', argument " "1"" of type '" "D3D12Pipe::RootTableRange *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12RootTableRange) /* defines _wrap_delete_D3D12RootTableRange_destructor_closure */

SWIGINTERN int _wrap_new_D3D12RootParam__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::RootParam *)new D3D12Pipe::RootParam();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__RootParam, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12RootParam__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::RootParam *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__RootParam,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12RootParam" "', argument " "1"" of type '" "D3D12Pipe::RootParam const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12RootParam" "', argument " "1"" of type '" "D3D12Pipe::RootParam const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  result = (D3D12Pipe::RootParam *)new D3D12Pipe::RootParam((D3D12Pipe::RootParam const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__RootParam, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12RootParam(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12RootParam",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12RootParam__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12RootParam__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12RootParam'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::RootParam::RootParam()\n"
    "    D3D12Pipe::RootParam::RootParam(D3D12Pipe::RootParam const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  D3D12Pipe::RootParam *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam___eq__" "', argument " "1"" of type '" "D3D12Pipe::RootParam const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__RootParam,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12RootParam___eq__" "', argument " "2"" of type '" "D3D12Pipe::RootParam const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12RootParam___eq__" "', argument " "2"" of type '" "D3D12Pipe::RootParam const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::RootParam * >(argp2);
  result = (bool)((D3D12Pipe::RootParam const *)arg1)->operator ==((D3D12Pipe::RootParam const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  D3D12Pipe::RootParam *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam___lt__" "', argument " "1"" of type '" "D3D12Pipe::RootParam const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__RootParam,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12RootParam___lt__" "', argument " "2"" of type '" "D3D12Pipe::RootParam const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12RootParam___lt__" "', argument " "2"" of type '" "D3D12Pipe::RootParam const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::RootParam * >(argp2);
  result = (bool)((D3D12Pipe::RootParam const *)arg1)->operator <((D3D12Pipe::RootParam const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  ShaderStageMask arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_visibility_set" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RootParam_visibility_set" "', argument " "2"" of type '" "ShaderStageMask""'");
  } 
  arg2 = static_cast< ShaderStageMask >(val2);
  if (arg1) (arg1)->visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStageMask result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootParam_visibility_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_visibility_get" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  result = (ShaderStageMask) ((arg1)->visibility);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStageMask->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_space_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_space_set" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RootParam_space_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->space = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_space_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootParam_space_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_space_get" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  result = (uint32_t) ((arg1)->space);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_reg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_reg_set" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RootParam_reg_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->reg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_reg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootParam_reg_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_reg_get" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  result = (uint32_t) ((arg1)->reg);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_constants_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  bytebuf *arg2 = (bytebuf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bytebuf temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_constants_set" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12RootParam_constants_set' argument 2 of type 'bytebuf'"); 
    }
  }
  if (arg1) (arg1)->constants = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_constants_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bytebuf *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootParam_constants_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_constants_get" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  result = (bytebuf *)& ((arg1)->constants);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_descriptor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  Descriptor *arg2 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_descriptor_set" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12RootParam_descriptor_set" "', argument " "2"" of type '" "Descriptor *""'"); 
  }
  arg2 = reinterpret_cast< Descriptor * >(argp2);
  if (arg1) (arg1)->descriptor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_descriptor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Descriptor *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootParam_descriptor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_descriptor_get" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  result = (Descriptor *)& ((arg1)->descriptor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Descriptor, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_heap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_heap_set" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12RootParam_heap_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->heap = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_heap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootParam_heap_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_heap_get" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  result = (ResourceId *)& ((arg1)->heap);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_heapByteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_heapByteOffset_set" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12RootParam_heapByteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->heapByteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_heapByteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootParam_heapByteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_heapByteOffset_get" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  result = (uint32_t) ((arg1)->heapByteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_tableRanges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  rdcarray< D3D12Pipe::RootTableRange > *arg2 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_tableRanges_set" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12RootParam_tableRanges_set' argument 2 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12RootParam_tableRanges_set' argument 2 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->tableRanges = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootParam_tableRanges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< D3D12Pipe::RootTableRange > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootParam_tableRanges_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootParam_tableRanges_get" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  result = (rdcarray< D3D12Pipe::RootTableRange > *)& ((arg1)->tableRanges);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_D3D12Pipe__RootTableRange_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12RootParam(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootParam *arg1 = (D3D12Pipe::RootParam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12RootParam",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootParam, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12RootParam" "', argument " "1"" of type '" "D3D12Pipe::RootParam *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootParam * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12RootParam) /* defines _wrap_delete_D3D12RootParam_destructor_closure */

SWIGINTERN int _wrap_new_D3D12StaticSampler__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::StaticSampler *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::StaticSampler *)new D3D12Pipe::StaticSampler();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__StaticSampler, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12StaticSampler__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::StaticSampler *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::StaticSampler *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__StaticSampler,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12StaticSampler" "', argument " "1"" of type '" "D3D12Pipe::StaticSampler const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12StaticSampler" "', argument " "1"" of type '" "D3D12Pipe::StaticSampler const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp1);
  result = (D3D12Pipe::StaticSampler *)new D3D12Pipe::StaticSampler((D3D12Pipe::StaticSampler const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__StaticSampler, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12StaticSampler(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12StaticSampler",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12StaticSampler__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12StaticSampler__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12StaticSampler'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::StaticSampler::StaticSampler()\n"
    "    D3D12Pipe::StaticSampler::StaticSampler(D3D12Pipe::StaticSampler const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12StaticSampler___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StaticSampler *arg1 = (D3D12Pipe::StaticSampler *) 0 ;
  D3D12Pipe::StaticSampler *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StaticSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StaticSampler___eq__" "', argument " "1"" of type '" "D3D12Pipe::StaticSampler const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__StaticSampler,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12StaticSampler___eq__" "', argument " "2"" of type '" "D3D12Pipe::StaticSampler const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12StaticSampler___eq__" "', argument " "2"" of type '" "D3D12Pipe::StaticSampler const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp2);
  result = (bool)((D3D12Pipe::StaticSampler const *)arg1)->operator ==((D3D12Pipe::StaticSampler const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StaticSampler___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StaticSampler *arg1 = (D3D12Pipe::StaticSampler *) 0 ;
  D3D12Pipe::StaticSampler *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StaticSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StaticSampler___lt__" "', argument " "1"" of type '" "D3D12Pipe::StaticSampler const *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_D3D12Pipe__StaticSampler,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12StaticSampler___lt__" "', argument " "2"" of type '" "D3D12Pipe::StaticSampler const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "D3D12StaticSampler___lt__" "', argument " "2"" of type '" "D3D12Pipe::StaticSampler const &""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp2);
  result = (bool)((D3D12Pipe::StaticSampler const *)arg1)->operator <((D3D12Pipe::StaticSampler const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StaticSampler_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StaticSampler *arg1 = (D3D12Pipe::StaticSampler *) 0 ;
  ShaderStageMask arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StaticSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StaticSampler_visibility_set" "', argument " "1"" of type '" "D3D12Pipe::StaticSampler *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12StaticSampler_visibility_set" "', argument " "2"" of type '" "ShaderStageMask""'");
  } 
  arg2 = static_cast< ShaderStageMask >(val2);
  if (arg1) (arg1)->visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StaticSampler_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StaticSampler *arg1 = (D3D12Pipe::StaticSampler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStageMask result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12StaticSampler_visibility_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StaticSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StaticSampler_visibility_get" "', argument " "1"" of type '" "D3D12Pipe::StaticSampler *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp1);
  result = (ShaderStageMask) ((arg1)->visibility);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStageMask->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StaticSampler_space_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StaticSampler *arg1 = (D3D12Pipe::StaticSampler *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StaticSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StaticSampler_space_set" "', argument " "1"" of type '" "D3D12Pipe::StaticSampler *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12StaticSampler_space_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->space = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StaticSampler_space_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StaticSampler *arg1 = (D3D12Pipe::StaticSampler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12StaticSampler_space_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StaticSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StaticSampler_space_get" "', argument " "1"" of type '" "D3D12Pipe::StaticSampler *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp1);
  result = (uint32_t) ((arg1)->space);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StaticSampler_reg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StaticSampler *arg1 = (D3D12Pipe::StaticSampler *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StaticSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StaticSampler_reg_set" "', argument " "1"" of type '" "D3D12Pipe::StaticSampler *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12StaticSampler_reg_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->reg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StaticSampler_reg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StaticSampler *arg1 = (D3D12Pipe::StaticSampler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12StaticSampler_reg_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StaticSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StaticSampler_reg_get" "', argument " "1"" of type '" "D3D12Pipe::StaticSampler *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp1);
  result = (uint32_t) ((arg1)->reg);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StaticSampler_descriptor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StaticSampler *arg1 = (D3D12Pipe::StaticSampler *) 0 ;
  SamplerDescriptor *arg2 = (SamplerDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StaticSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StaticSampler_descriptor_set" "', argument " "1"" of type '" "D3D12Pipe::StaticSampler *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12StaticSampler_descriptor_set" "', argument " "2"" of type '" "SamplerDescriptor *""'"); 
  }
  arg2 = reinterpret_cast< SamplerDescriptor * >(argp2);
  if (arg1) (arg1)->descriptor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12StaticSampler_descriptor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StaticSampler *arg1 = (D3D12Pipe::StaticSampler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SamplerDescriptor *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12StaticSampler_descriptor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StaticSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12StaticSampler_descriptor_get" "', argument " "1"" of type '" "D3D12Pipe::StaticSampler *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp1);
  result = (SamplerDescriptor *)& ((arg1)->descriptor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SamplerDescriptor, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12StaticSampler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::StaticSampler *arg1 = (D3D12Pipe::StaticSampler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12StaticSampler",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__StaticSampler, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12StaticSampler" "', argument " "1"" of type '" "D3D12Pipe::StaticSampler *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12StaticSampler) /* defines _wrap_delete_D3D12StaticSampler_destructor_closure */

SWIGINTERN int _wrap_new_D3D12RootSignature__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootSignature *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::RootSignature *)new D3D12Pipe::RootSignature();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__RootSignature, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12RootSignature__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootSignature *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::RootSignature *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__RootSignature,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12RootSignature" "', argument " "1"" of type '" "D3D12Pipe::RootSignature const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12RootSignature" "', argument " "1"" of type '" "D3D12Pipe::RootSignature const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootSignature * >(argp1);
  result = (D3D12Pipe::RootSignature *)new D3D12Pipe::RootSignature((D3D12Pipe::RootSignature const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__RootSignature, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12RootSignature(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12RootSignature",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12RootSignature__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12RootSignature__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12RootSignature'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::RootSignature::RootSignature()\n"
    "    D3D12Pipe::RootSignature::RootSignature(D3D12Pipe::RootSignature const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12RootSignature_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootSignature *arg1 = (D3D12Pipe::RootSignature *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootSignature, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootSignature_resourceId_set" "', argument " "1"" of type '" "D3D12Pipe::RootSignature *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootSignature * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12RootSignature_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootSignature_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootSignature *arg1 = (D3D12Pipe::RootSignature *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootSignature_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootSignature, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootSignature_resourceId_get" "', argument " "1"" of type '" "D3D12Pipe::RootSignature *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootSignature * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootSignature_parameters_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootSignature *arg1 = (D3D12Pipe::RootSignature *) 0 ;
  rdcarray< D3D12Pipe::RootParam > *arg2 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootSignature, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootSignature_parameters_set" "', argument " "1"" of type '" "D3D12Pipe::RootSignature *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootSignature * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12RootSignature_parameters_set' argument 2 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12RootSignature_parameters_set' argument 2 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->parameters = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootSignature_parameters_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootSignature *arg1 = (D3D12Pipe::RootSignature *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< D3D12Pipe::RootParam > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootSignature_parameters_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootSignature, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootSignature_parameters_get" "', argument " "1"" of type '" "D3D12Pipe::RootSignature *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootSignature * >(argp1);
  result = (rdcarray< D3D12Pipe::RootParam > *)& ((arg1)->parameters);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_D3D12Pipe__RootParam_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootSignature_staticSamplers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootSignature *arg1 = (D3D12Pipe::RootSignature *) 0 ;
  rdcarray< D3D12Pipe::StaticSampler > *arg2 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootSignature, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootSignature_staticSamplers_set" "', argument " "1"" of type '" "D3D12Pipe::RootSignature *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootSignature * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12RootSignature_staticSamplers_set' argument 2 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12RootSignature_staticSamplers_set' argument 2 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->staticSamplers = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12RootSignature_staticSamplers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootSignature *arg1 = (D3D12Pipe::RootSignature *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< D3D12Pipe::StaticSampler > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12RootSignature_staticSamplers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootSignature, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12RootSignature_staticSamplers_get" "', argument " "1"" of type '" "D3D12Pipe::RootSignature *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootSignature * >(argp1);
  result = (rdcarray< D3D12Pipe::StaticSampler > *)& ((arg1)->staticSamplers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_D3D12Pipe__StaticSampler_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12RootSignature(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::RootSignature *arg1 = (D3D12Pipe::RootSignature *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12RootSignature",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__RootSignature, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12RootSignature" "', argument " "1"" of type '" "D3D12Pipe::RootSignature *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::RootSignature * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12RootSignature) /* defines _wrap_delete_D3D12RootSignature_destructor_closure */

SWIGINTERN int _wrap_new_D3D12Predication__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  D3D12Pipe::Predication *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (D3D12Pipe::Predication *)new D3D12Pipe::Predication();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Predication, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12Predication__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  D3D12Pipe::Predication *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  D3D12Pipe::Predication *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_D3D12Pipe__Predication,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_D3D12Predication" "', argument " "1"" of type '" "D3D12Pipe::Predication const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_D3D12Predication" "', argument " "1"" of type '" "D3D12Pipe::Predication const &""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Predication * >(argp1);
  result = (D3D12Pipe::Predication *)new D3D12Pipe::Predication((D3D12Pipe::Predication const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Predication, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_D3D12Predication(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_D3D12Predication",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_D3D12Predication__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_D3D12Predication__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_D3D12Predication'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    D3D12Pipe::Predication::Predication()\n"
    "    D3D12Pipe::Predication::Predication(D3D12Pipe::Predication const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_D3D12Predication_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Predication *arg1 = (D3D12Pipe::Predication *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Predication_resourceId_set" "', argument " "1"" of type '" "D3D12Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Predication * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12Predication_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Predication_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Predication *arg1 = (D3D12Pipe::Predication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Predication_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Predication_resourceId_get" "', argument " "1"" of type '" "D3D12Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Predication * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Predication_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Predication *arg1 = (D3D12Pipe::Predication *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Predication_offset_set" "', argument " "1"" of type '" "D3D12Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Predication * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12Predication_offset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Predication_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Predication *arg1 = (D3D12Pipe::Predication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Predication_offset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Predication_offset_get" "', argument " "1"" of type '" "D3D12Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Predication * >(argp1);
  result = (uint64_t) ((arg1)->offset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Predication_skipIfZero_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Predication *arg1 = (D3D12Pipe::Predication *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Predication_skipIfZero_set" "', argument " "1"" of type '" "D3D12Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Predication * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "D3D12Predication_skipIfZero_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->skipIfZero = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12Predication_skipIfZero_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Predication *arg1 = (D3D12Pipe::Predication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12Predication_skipIfZero_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12Predication_skipIfZero_get" "', argument " "1"" of type '" "D3D12Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Predication * >(argp1);
  result = (bool) ((arg1)->skipIfZero);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12Predication(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::Predication *arg1 = (D3D12Pipe::Predication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12Predication",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__Predication, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12Predication" "', argument " "1"" of type '" "D3D12Pipe::Predication *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::Predication * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12Predication) /* defines _wrap_delete_D3D12Predication_destructor_closure */

SWIGINTERN PyObject *_wrap_D3D12State_pipelineResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_pipelineResourceId_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_pipelineResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->pipelineResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_pipelineResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_pipelineResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_pipelineResourceId_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (ResourceId *)& ((arg1)->pipelineResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_descriptorHeaps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  rdcarray< ResourceId > *arg2 = (rdcarray< ResourceId > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_descriptorHeaps_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12State_descriptorHeaps_set' argument 2 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12State_descriptorHeaps_set' argument 2 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->descriptorHeaps = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_descriptorHeaps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ResourceId > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_descriptorHeaps_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_descriptorHeaps_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (rdcarray< ResourceId > *)& ((arg1)->descriptorHeaps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ResourceId_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_rootSignature_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::RootSignature *arg2 = (D3D12Pipe::RootSignature *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_rootSignature_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__RootSignature, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_rootSignature_set" "', argument " "2"" of type '" "D3D12Pipe::RootSignature *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::RootSignature * >(argp2);
  if (arg1) (arg1)->rootSignature = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_rootSignature_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::RootSignature *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_rootSignature_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_rootSignature_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::RootSignature *)& ((arg1)->rootSignature);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__RootSignature, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_inputAssembly_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::InputAssembly *arg2 = (D3D12Pipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_inputAssembly_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_inputAssembly_set" "', argument " "2"" of type '" "D3D12Pipe::InputAssembly *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::InputAssembly * >(argp2);
  if (arg1) (arg1)->inputAssembly = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_inputAssembly_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::InputAssembly *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_inputAssembly_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_inputAssembly_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::InputAssembly *)& ((arg1)->inputAssembly);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__InputAssembly, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_vertexShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::Shader *arg2 = (D3D12Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_vertexShader_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_vertexShader_set" "', argument " "2"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::Shader * >(argp2);
  if (arg1) (arg1)->vertexShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_vertexShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_vertexShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_vertexShader_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::Shader *)& ((arg1)->vertexShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_hullShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::Shader *arg2 = (D3D12Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_hullShader_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_hullShader_set" "', argument " "2"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::Shader * >(argp2);
  if (arg1) (arg1)->hullShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_hullShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_hullShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_hullShader_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::Shader *)& ((arg1)->hullShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_domainShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::Shader *arg2 = (D3D12Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_domainShader_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_domainShader_set" "', argument " "2"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::Shader * >(argp2);
  if (arg1) (arg1)->domainShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_domainShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_domainShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_domainShader_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::Shader *)& ((arg1)->domainShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_geometryShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::Shader *arg2 = (D3D12Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_geometryShader_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_geometryShader_set" "', argument " "2"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::Shader * >(argp2);
  if (arg1) (arg1)->geometryShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_geometryShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_geometryShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_geometryShader_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::Shader *)& ((arg1)->geometryShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_pixelShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::Shader *arg2 = (D3D12Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_pixelShader_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_pixelShader_set" "', argument " "2"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::Shader * >(argp2);
  if (arg1) (arg1)->pixelShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_pixelShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_pixelShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_pixelShader_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::Shader *)& ((arg1)->pixelShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_computeShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::Shader *arg2 = (D3D12Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_computeShader_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_computeShader_set" "', argument " "2"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::Shader * >(argp2);
  if (arg1) (arg1)->computeShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_computeShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_computeShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_computeShader_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::Shader *)& ((arg1)->computeShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_ampShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::Shader *arg2 = (D3D12Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_ampShader_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_ampShader_set" "', argument " "2"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::Shader * >(argp2);
  if (arg1) (arg1)->ampShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_ampShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_ampShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_ampShader_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::Shader *)& ((arg1)->ampShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_meshShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::Shader *arg2 = (D3D12Pipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_meshShader_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_meshShader_set" "', argument " "2"" of type '" "D3D12Pipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::Shader * >(argp2);
  if (arg1) (arg1)->meshShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_meshShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_meshShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_meshShader_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::Shader *)& ((arg1)->meshShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_streamOut_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::StreamOut *arg2 = (D3D12Pipe::StreamOut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_streamOut_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__StreamOut, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_streamOut_set" "', argument " "2"" of type '" "D3D12Pipe::StreamOut *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::StreamOut * >(argp2);
  if (arg1) (arg1)->streamOut = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_streamOut_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::StreamOut *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_streamOut_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_streamOut_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::StreamOut *)& ((arg1)->streamOut);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__StreamOut, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_rasterizer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::Rasterizer *arg2 = (D3D12Pipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_rasterizer_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_rasterizer_set" "', argument " "2"" of type '" "D3D12Pipe::Rasterizer *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::Rasterizer * >(argp2);
  if (arg1) (arg1)->rasterizer = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_rasterizer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::Rasterizer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_rasterizer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_rasterizer_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::Rasterizer *)& ((arg1)->rasterizer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Rasterizer, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_outputMerger_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::OM *arg2 = (D3D12Pipe::OM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_outputMerger_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_outputMerger_set" "', argument " "2"" of type '" "D3D12Pipe::OM *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::OM * >(argp2);
  if (arg1) (arg1)->outputMerger = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_outputMerger_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::OM *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_outputMerger_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_outputMerger_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::OM *)& ((arg1)->outputMerger);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__OM, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_predication_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  D3D12Pipe::Predication *arg2 = (D3D12Pipe::Predication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_predication_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_D3D12Pipe__Predication, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "D3D12State_predication_set" "', argument " "2"" of type '" "D3D12Pipe::Predication *""'"); 
  }
  arg2 = reinterpret_cast< D3D12Pipe::Predication * >(argp2);
  if (arg1) (arg1)->predication = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_predication_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  D3D12Pipe::Predication *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_predication_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_predication_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (D3D12Pipe::Predication *)& ((arg1)->predication);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_D3D12Pipe__Predication, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_resourceStates_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  rdcarray< D3D12Pipe::ResourceData > *arg2 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_resourceStates_set" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'D3D12State_resourceStates_set' argument 2 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'D3D12State_resourceStates_set' argument 2 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->resourceStates = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_D3D12State_resourceStates_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< D3D12Pipe::ResourceData > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"D3D12State_resourceStates_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "D3D12State_resourceStates_get" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  result = (rdcarray< D3D12Pipe::ResourceData > *)& ((arg1)->resourceStates);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_D3D12Pipe__ResourceData_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_D3D12State(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  D3D12Pipe::State *arg1 = (D3D12Pipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_D3D12State",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_D3D12Pipe__State, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_D3D12State" "', argument " "1"" of type '" "D3D12Pipe::State *""'"); 
  }
  arg1 = reinterpret_cast< D3D12Pipe::State * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_D3D12State) /* defines _wrap_delete_D3D12State_destructor_closure */

SWIGINTERN int _wrap_new_FloatVector__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FloatVector *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (FloatVector *)new FloatVector();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloatVector, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_FloatVector__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FloatVector *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FloatVector,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatVector" "', argument " "1"" of type '" "FloatVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatVector" "', argument " "1"" of type '" "FloatVector const &""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  result = (FloatVector *)new FloatVector((FloatVector const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloatVector, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_FloatVector__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  FloatVector *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatVector" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatVector" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatVector" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FloatVector" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  result = (FloatVector *)new FloatVector(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloatVector, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_FloatVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_FloatVector",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_FloatVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_FloatVector__SWIG_1(self, argc, argv);
  }
  if (argc == 4) {
    return _wrap_new_FloatVector__SWIG_2(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FloatVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FloatVector::FloatVector()\n"
    "    FloatVector::FloatVector(FloatVector const &)\n"
    "    FloatVector::FloatVector(float,float,float,float)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_FloatVector___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = (FloatVector *) 0 ;
  FloatVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___eq__" "', argument " "1"" of type '" "FloatVector const *""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_FloatVector,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatVector___eq__" "', argument " "2"" of type '" "FloatVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatVector___eq__" "', argument " "2"" of type '" "FloatVector const &""'"); 
  }
  arg2 = reinterpret_cast< FloatVector * >(argp2);
  result = (bool)((FloatVector const *)arg1)->operator ==((FloatVector const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatVector___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = (FloatVector *) 0 ;
  FloatVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___ne__" "', argument " "1"" of type '" "FloatVector const *""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_FloatVector,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatVector___ne__" "', argument " "2"" of type '" "FloatVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatVector___ne__" "', argument " "2"" of type '" "FloatVector const &""'"); 
  }
  arg2 = reinterpret_cast< FloatVector * >(argp2);
  result = (bool)((FloatVector const *)arg1)->operator !=((FloatVector const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatVector___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = (FloatVector *) 0 ;
  FloatVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___lt__" "', argument " "1"" of type '" "FloatVector const *""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_FloatVector,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatVector___lt__" "', argument " "2"" of type '" "FloatVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatVector___lt__" "', argument " "2"" of type '" "FloatVector const &""'"); 
  }
  arg2 = reinterpret_cast< FloatVector * >(argp2);
  result = (bool)((FloatVector const *)arg1)->operator <((FloatVector const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatVector_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = (FloatVector *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_x_set" "', argument " "1"" of type '" "FloatVector *""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_x_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatVector_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"FloatVector_x_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_x_get" "', argument " "1"" of type '" "FloatVector *""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  result = (float) ((arg1)->x);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatVector_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = (FloatVector *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_y_set" "', argument " "1"" of type '" "FloatVector *""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_y_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatVector_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"FloatVector_y_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_y_get" "', argument " "1"" of type '" "FloatVector *""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  result = (float) ((arg1)->y);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatVector_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = (FloatVector *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_z_set" "', argument " "1"" of type '" "FloatVector *""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_z_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatVector_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"FloatVector_z_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_z_get" "', argument " "1"" of type '" "FloatVector *""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  result = (float) ((arg1)->z);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatVector_w_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = (FloatVector *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_w_set" "', argument " "1"" of type '" "FloatVector *""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_w_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->w = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatVector_w_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"FloatVector_w_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_w_get" "', argument " "1"" of type '" "FloatVector *""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  result = (float) ((arg1)->w);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FloatVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_FloatVector",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FloatVector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatVector" "', argument " "1"" of type '" "FloatVector *""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_FloatVector) /* defines _wrap_delete_FloatVector_destructor_closure */

SWIGINTERN int _wrap_new_AxisMapping__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  AxisMapping *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (AxisMapping *)new AxisMapping();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AxisMapping, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_AxisMapping__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FloatVector *arg1 = 0 ;
  FloatVector *arg2 = 0 ;
  FloatVector *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  AxisMapping *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FloatVector,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AxisMapping" "', argument " "1"" of type '" "FloatVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AxisMapping" "', argument " "1"" of type '" "FloatVector const &""'"); 
  }
  arg1 = reinterpret_cast< FloatVector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FloatVector,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AxisMapping" "', argument " "2"" of type '" "FloatVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AxisMapping" "', argument " "2"" of type '" "FloatVector const &""'"); 
  }
  arg2 = reinterpret_cast< FloatVector * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FloatVector,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AxisMapping" "', argument " "3"" of type '" "FloatVector const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AxisMapping" "', argument " "3"" of type '" "FloatVector const &""'"); 
  }
  arg3 = reinterpret_cast< FloatVector * >(argp3);
  result = (AxisMapping *)new AxisMapping((FloatVector const &)*arg1,(FloatVector const &)*arg2,(FloatVector const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AxisMapping, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_AxisMapping__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AxisMapping *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  AxisMapping *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_AxisMapping,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AxisMapping" "', argument " "1"" of type '" "AxisMapping const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AxisMapping" "', argument " "1"" of type '" "AxisMapping const &""'"); 
  }
  arg1 = reinterpret_cast< AxisMapping * >(argp1);
  result = (AxisMapping *)new AxisMapping((AxisMapping const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AxisMapping, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_AxisMapping(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_AxisMapping",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_AxisMapping__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_AxisMapping__SWIG_2(self, argc, argv);
  }
  if (argc == 3) {
    return _wrap_new_AxisMapping__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AxisMapping'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AxisMapping::AxisMapping()\n"
    "    AxisMapping::AxisMapping(FloatVector const &,FloatVector const &,FloatVector const &)\n"
    "    AxisMapping::AxisMapping(AxisMapping const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_AxisMapping_xAxis_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AxisMapping *arg1 = (AxisMapping *) 0 ;
  FloatVector *arg2 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_AxisMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AxisMapping_xAxis_set" "', argument " "1"" of type '" "AxisMapping *""'"); 
  }
  arg1 = reinterpret_cast< AxisMapping * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AxisMapping_xAxis_set" "', argument " "2"" of type '" "FloatVector *""'"); 
  }
  arg2 = reinterpret_cast< FloatVector * >(argp2);
  if (arg1) (arg1)->xAxis = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AxisMapping_xAxis_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AxisMapping *arg1 = (AxisMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatVector *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"AxisMapping_xAxis_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_AxisMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AxisMapping_xAxis_get" "', argument " "1"" of type '" "AxisMapping *""'"); 
  }
  arg1 = reinterpret_cast< AxisMapping * >(argp1);
  result = (FloatVector *)& ((arg1)->xAxis);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloatVector, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AxisMapping_yAxis_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AxisMapping *arg1 = (AxisMapping *) 0 ;
  FloatVector *arg2 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_AxisMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AxisMapping_yAxis_set" "', argument " "1"" of type '" "AxisMapping *""'"); 
  }
  arg1 = reinterpret_cast< AxisMapping * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AxisMapping_yAxis_set" "', argument " "2"" of type '" "FloatVector *""'"); 
  }
  arg2 = reinterpret_cast< FloatVector * >(argp2);
  if (arg1) (arg1)->yAxis = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AxisMapping_yAxis_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AxisMapping *arg1 = (AxisMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatVector *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"AxisMapping_yAxis_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_AxisMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AxisMapping_yAxis_get" "', argument " "1"" of type '" "AxisMapping *""'"); 
  }
  arg1 = reinterpret_cast< AxisMapping * >(argp1);
  result = (FloatVector *)& ((arg1)->yAxis);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloatVector, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AxisMapping_zAxis_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AxisMapping *arg1 = (AxisMapping *) 0 ;
  FloatVector *arg2 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_AxisMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AxisMapping_zAxis_set" "', argument " "1"" of type '" "AxisMapping *""'"); 
  }
  arg1 = reinterpret_cast< AxisMapping * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AxisMapping_zAxis_set" "', argument " "2"" of type '" "FloatVector *""'"); 
  }
  arg2 = reinterpret_cast< FloatVector * >(argp2);
  if (arg1) (arg1)->zAxis = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AxisMapping_zAxis_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AxisMapping *arg1 = (AxisMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatVector *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"AxisMapping_zAxis_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_AxisMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AxisMapping_zAxis_get" "', argument " "1"" of type '" "AxisMapping *""'"); 
  }
  arg1 = reinterpret_cast< AxisMapping * >(argp1);
  result = (FloatVector *)& ((arg1)->zAxis);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloatVector, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AxisMapping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AxisMapping *arg1 = (AxisMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_AxisMapping",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_AxisMapping, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AxisMapping" "', argument " "1"" of type '" "AxisMapping *""'"); 
  }
  arg1 = reinterpret_cast< AxisMapping * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_AxisMapping) /* defines _wrap_delete_AxisMapping_destructor_closure */

SWIGINTERN int _wrap_new_PathEntry__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  PathEntry *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (PathEntry *)new PathEntry();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PathEntry, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_PathEntry__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PathEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PathEntry *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_PathEntry,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PathEntry" "', argument " "1"" of type '" "PathEntry const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PathEntry" "', argument " "1"" of type '" "PathEntry const &""'"); 
  }
  arg1 = reinterpret_cast< PathEntry * >(argp1);
  result = (PathEntry *)new PathEntry((PathEntry const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PathEntry, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_PathEntry__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  PathProperty arg2 ;
  rdcstr temp1 ;
  int val2 ;
  int ecode2 = 0 ;
  PathEntry *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_PathEntry' argument 1 of type 'rdcstr'"); 
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PathEntry" "', argument " "2"" of type '" "PathProperty""'");
  } 
  arg2 = static_cast< PathProperty >(val2);
  result = (PathEntry *)new PathEntry((rdcstr const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PathEntry, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_PathEntry(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PathEntry",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_PathEntry__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_PathEntry__SWIG_1(self, argc, argv);
  }
  if (argc == 2) {
    return _wrap_new_PathEntry__SWIG_2(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PathEntry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PathEntry::PathEntry()\n"
    "    PathEntry::PathEntry(PathEntry const &)\n"
    "    PathEntry::PathEntry(rdcstr const &,PathProperty)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_PathEntry___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathEntry *arg1 = (PathEntry *) 0 ;
  PathEntry *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PathEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathEntry___lt__" "', argument " "1"" of type '" "PathEntry const *""'"); 
  }
  arg1 = reinterpret_cast< PathEntry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_PathEntry,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PathEntry___lt__" "', argument " "2"" of type '" "PathEntry const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PathEntry___lt__" "', argument " "2"" of type '" "PathEntry const &""'"); 
  }
  arg2 = reinterpret_cast< PathEntry * >(argp2);
  result = (bool)((PathEntry const *)arg1)->operator <((PathEntry const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathEntry_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathEntry *arg1 = (PathEntry *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PathEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathEntry_filename_set" "', argument " "1"" of type '" "PathEntry *""'"); 
  }
  arg1 = reinterpret_cast< PathEntry * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'PathEntry_filename_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->filename = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathEntry_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathEntry *arg1 = (PathEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"PathEntry_filename_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PathEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathEntry_filename_get" "', argument " "1"" of type '" "PathEntry *""'"); 
  }
  arg1 = reinterpret_cast< PathEntry * >(argp1);
  result =  ((arg1)->filename);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathEntry_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathEntry *arg1 = (PathEntry *) 0 ;
  PathProperty arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PathEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathEntry_flags_set" "', argument " "1"" of type '" "PathEntry *""'"); 
  }
  arg1 = reinterpret_cast< PathEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathEntry_flags_set" "', argument " "2"" of type '" "PathProperty""'");
  } 
  arg2 = static_cast< PathProperty >(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathEntry_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathEntry *arg1 = (PathEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PathProperty result;
  
  if (!SWIG_Python_UnpackTuple(args,"PathEntry_flags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PathEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathEntry_flags_get" "', argument " "1"" of type '" "PathEntry *""'"); 
  }
  arg1 = reinterpret_cast< PathEntry * >(argp1);
  result = (PathProperty) ((arg1)->flags);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_PathProperty->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathEntry_lastmod_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathEntry *arg1 = (PathEntry *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PathEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathEntry_lastmod_set" "', argument " "1"" of type '" "PathEntry *""'"); 
  }
  arg1 = reinterpret_cast< PathEntry * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathEntry_lastmod_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->lastmod = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathEntry_lastmod_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathEntry *arg1 = (PathEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"PathEntry_lastmod_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PathEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathEntry_lastmod_get" "', argument " "1"" of type '" "PathEntry *""'"); 
  }
  arg1 = reinterpret_cast< PathEntry * >(argp1);
  result = (uint32_t) ((arg1)->lastmod);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathEntry_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathEntry *arg1 = (PathEntry *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PathEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathEntry_size_set" "', argument " "1"" of type '" "PathEntry *""'"); 
  }
  arg1 = reinterpret_cast< PathEntry * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathEntry_size_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathEntry_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathEntry *arg1 = (PathEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"PathEntry_size_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PathEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathEntry_size_get" "', argument " "1"" of type '" "PathEntry *""'"); 
  }
  arg1 = reinterpret_cast< PathEntry * >(argp1);
  result = (uint64_t) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathEntry___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathEntry *arg1 = (PathEntry *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PathEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathEntry___eq__" "', argument " "1"" of type '" "PathEntry *""'"); 
  }
  arg1 = reinterpret_cast< PathEntry * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)PathEntry___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathEntry___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathEntry *arg1 = (PathEntry *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PathEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathEntry___ne__" "', argument " "1"" of type '" "PathEntry *""'"); 
  }
  arg1 = reinterpret_cast< PathEntry * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)PathEntry___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PathEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathEntry *arg1 = (PathEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_PathEntry",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PathEntry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PathEntry" "', argument " "1"" of type '" "PathEntry *""'"); 
  }
  arg1 = reinterpret_cast< PathEntry * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_PathEntry) /* defines _wrap_delete_PathEntry_destructor_closure */

SWIGINTERN int _wrap_new_SectionProperties__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SectionProperties *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SectionProperties *)new SectionProperties();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SectionProperties, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_SectionProperties__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SectionProperties *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SectionProperties,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SectionProperties" "', argument " "1"" of type '" "SectionProperties const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SectionProperties" "', argument " "1"" of type '" "SectionProperties const &""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  result = (SectionProperties *)new SectionProperties((SectionProperties const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SectionProperties, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_SectionProperties(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SectionProperties",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SectionProperties__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_SectionProperties__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SectionProperties'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SectionProperties::SectionProperties()\n"
    "    SectionProperties::SectionProperties(SectionProperties const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_SectionProperties_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = (SectionProperties *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SectionProperties_name_set" "', argument " "1"" of type '" "SectionProperties *""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SectionProperties_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SectionProperties_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = (SectionProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"SectionProperties_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SectionProperties_name_get" "', argument " "1"" of type '" "SectionProperties *""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SectionProperties_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = (SectionProperties *) 0 ;
  SectionType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SectionProperties_type_set" "', argument " "1"" of type '" "SectionProperties *""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SectionProperties_type_set" "', argument " "2"" of type '" "SectionType""'");
  } 
  arg2 = static_cast< SectionType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SectionProperties_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = (SectionProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SectionType result;
  
  if (!SWIG_Python_UnpackTuple(args,"SectionProperties_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SectionProperties_type_get" "', argument " "1"" of type '" "SectionProperties *""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  result = (SectionType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_SectionType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SectionProperties_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = (SectionProperties *) 0 ;
  SectionFlags arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SectionProperties_flags_set" "', argument " "1"" of type '" "SectionProperties *""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SectionProperties_flags_set" "', argument " "2"" of type '" "SectionFlags""'");
  } 
  arg2 = static_cast< SectionFlags >(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SectionProperties_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = (SectionProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SectionFlags result;
  
  if (!SWIG_Python_UnpackTuple(args,"SectionProperties_flags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SectionProperties_flags_get" "', argument " "1"" of type '" "SectionProperties *""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  result = (SectionFlags) ((arg1)->flags);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_SectionFlags->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SectionProperties_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = (SectionProperties *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SectionProperties_version_set" "', argument " "1"" of type '" "SectionProperties *""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SectionProperties_version_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SectionProperties_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = (SectionProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SectionProperties_version_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SectionProperties_version_get" "', argument " "1"" of type '" "SectionProperties *""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  result = (uint64_t) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SectionProperties_uncompressedSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = (SectionProperties *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SectionProperties_uncompressedSize_set" "', argument " "1"" of type '" "SectionProperties *""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SectionProperties_uncompressedSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->uncompressedSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SectionProperties_uncompressedSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = (SectionProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SectionProperties_uncompressedSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SectionProperties_uncompressedSize_get" "', argument " "1"" of type '" "SectionProperties *""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  result = (uint64_t) ((arg1)->uncompressedSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SectionProperties_compressedSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = (SectionProperties *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SectionProperties_compressedSize_set" "', argument " "1"" of type '" "SectionProperties *""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SectionProperties_compressedSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->compressedSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SectionProperties_compressedSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = (SectionProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SectionProperties_compressedSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SectionProperties_compressedSize_get" "', argument " "1"" of type '" "SectionProperties *""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  result = (uint64_t) ((arg1)->compressedSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SectionProperties(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionProperties *arg1 = (SectionProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_SectionProperties",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionProperties, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SectionProperties" "', argument " "1"" of type '" "SectionProperties *""'"); 
  }
  arg1 = reinterpret_cast< SectionProperties * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_SectionProperties) /* defines _wrap_delete_SectionProperties_destructor_closure */

SWIGINTERN int _wrap_new_ResourceFormat__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ResourceFormat *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ResourceFormat *)new ResourceFormat();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceFormat, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ResourceFormat__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ResourceFormat *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ResourceFormat,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ResourceFormat" "', argument " "1"" of type '" "ResourceFormat const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ResourceFormat" "', argument " "1"" of type '" "ResourceFormat const &""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  result = (ResourceFormat *)new ResourceFormat((ResourceFormat const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceFormat, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ResourceFormat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ResourceFormat",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ResourceFormat__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ResourceFormat__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ResourceFormat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ResourceFormat::ResourceFormat()\n"
    "    ResourceFormat::ResourceFormat(ResourceFormat const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ResourceFormat___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  ResourceFormat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat___eq__" "', argument " "1"" of type '" "ResourceFormat const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceFormat,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResourceFormat___eq__" "', argument " "2"" of type '" "ResourceFormat const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ResourceFormat___eq__" "', argument " "2"" of type '" "ResourceFormat const &""'"); 
  }
  arg2 = reinterpret_cast< ResourceFormat * >(argp2);
  result = (bool)((ResourceFormat const *)arg1)->operator ==((ResourceFormat const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  ResourceFormat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat___lt__" "', argument " "1"" of type '" "ResourceFormat const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceFormat,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResourceFormat___lt__" "', argument " "2"" of type '" "ResourceFormat const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ResourceFormat___lt__" "', argument " "2"" of type '" "ResourceFormat const &""'"); 
  }
  arg2 = reinterpret_cast< ResourceFormat * >(argp2);
  result = (bool)((ResourceFormat const *)arg1)->operator <((ResourceFormat const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  ResourceFormat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat___ne__" "', argument " "1"" of type '" "ResourceFormat const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceFormat,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResourceFormat___ne__" "', argument " "2"" of type '" "ResourceFormat const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ResourceFormat___ne__" "', argument " "2"" of type '" "ResourceFormat const &""'"); 
  }
  arg2 = reinterpret_cast< ResourceFormat * >(argp2);
  result = (bool)((ResourceFormat const *)arg1)->operator !=((ResourceFormat const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_Name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceFormat_Name",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_Name" "', argument " "1"" of type '" "ResourceFormat const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  result = ((ResourceFormat const *)arg1)->Name();
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_Special(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceFormat_Special",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_Special" "', argument " "1"" of type '" "ResourceFormat const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  result = (bool)((ResourceFormat const *)arg1)->Special();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_BGRAOrder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceFormat_BGRAOrder",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_BGRAOrder" "', argument " "1"" of type '" "ResourceFormat const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  result = (bool)((ResourceFormat const *)arg1)->BGRAOrder();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_SRGBCorrected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceFormat_SRGBCorrected",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_SRGBCorrected" "', argument " "1"" of type '" "ResourceFormat const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  result = (bool)((ResourceFormat const *)arg1)->SRGBCorrected();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_YUVSubsampling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceFormat_YUVSubsampling",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_YUVSubsampling" "', argument " "1"" of type '" "ResourceFormat const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  result = (uint32_t)((ResourceFormat const *)arg1)->YUVSubsampling();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_YUVPlaneCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceFormat_YUVPlaneCount",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_YUVPlaneCount" "', argument " "1"" of type '" "ResourceFormat const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  result = (uint32_t)((ResourceFormat const *)arg1)->YUVPlaneCount();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_SetBGRAOrder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_SetBGRAOrder" "', argument " "1"" of type '" "ResourceFormat *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceFormat_SetBGRAOrder" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->SetBGRAOrder(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_SetYUVSubsampling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_SetYUVSubsampling" "', argument " "1"" of type '" "ResourceFormat *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceFormat_SetYUVSubsampling" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  (arg1)->SetYUVSubsampling(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_SetYUVPlaneCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_SetYUVPlaneCount" "', argument " "1"" of type '" "ResourceFormat *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceFormat_SetYUVPlaneCount" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  (arg1)->SetYUVPlaneCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_BlockFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceFormat_BlockFormat",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_BlockFormat" "', argument " "1"" of type '" "ResourceFormat const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  result = (bool)((ResourceFormat const *)arg1)->BlockFormat();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_ElementSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceFormat_ElementSize",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_ElementSize" "', argument " "1"" of type '" "ResourceFormat const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  result = (uint32_t)((ResourceFormat const *)arg1)->ElementSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  ResourceFormatType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_type_set" "', argument " "1"" of type '" "ResourceFormat *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceFormat_type_set" "', argument " "2"" of type '" "ResourceFormatType""'");
  } 
  arg2 = static_cast< ResourceFormatType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceFormatType result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceFormat_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_type_get" "', argument " "1"" of type '" "ResourceFormat *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  result = (ResourceFormatType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ResourceFormatType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_compType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  CompType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_compType_set" "', argument " "1"" of type '" "ResourceFormat *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceFormat_compType_set" "', argument " "2"" of type '" "CompType""'");
  } 
  arg2 = static_cast< CompType >(val2);
  if (arg1) (arg1)->compType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_compType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompType result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceFormat_compType_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_compType_get" "', argument " "1"" of type '" "ResourceFormat *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  result = (CompType) ((arg1)->compType);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CompType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_compCount_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_compCount_set" "', argument " "1"" of type '" "ResourceFormat *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceFormat_compCount_set" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  if (arg1) (arg1)->compCount = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_compCount_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceFormat_compCount_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_compCount_get" "', argument " "1"" of type '" "ResourceFormat *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  result = (uint8_t) ((arg1)->compCount);
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_compByteWidth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_compByteWidth_set" "', argument " "1"" of type '" "ResourceFormat *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceFormat_compByteWidth_set" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  if (arg1) (arg1)->compByteWidth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceFormat_compByteWidth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceFormat_compByteWidth_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceFormat_compByteWidth_get" "', argument " "1"" of type '" "ResourceFormat *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  result = (uint8_t) ((arg1)->compByteWidth);
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResourceFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormat *arg1 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ResourceFormat",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResourceFormat" "', argument " "1"" of type '" "ResourceFormat *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormat * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ResourceFormat) /* defines _wrap_delete_ResourceFormat_destructor_closure */

SWIGINTERN int _wrap_new_TextureFilter__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TextureFilter *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (TextureFilter *)new TextureFilter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureFilter, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureFilter__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TextureFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TextureFilter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TextureFilter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TextureFilter" "', argument " "1"" of type '" "TextureFilter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TextureFilter" "', argument " "1"" of type '" "TextureFilter const &""'"); 
  }
  arg1 = reinterpret_cast< TextureFilter * >(argp1);
  result = (TextureFilter *)new TextureFilter((TextureFilter const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureFilter, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureFilter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_TextureFilter",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TextureFilter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_TextureFilter__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TextureFilter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TextureFilter::TextureFilter()\n"
    "    TextureFilter::TextureFilter(TextureFilter const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_TextureFilter___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureFilter *arg1 = (TextureFilter *) 0 ;
  TextureFilter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureFilter___eq__" "', argument " "1"" of type '" "TextureFilter const *""'"); 
  }
  arg1 = reinterpret_cast< TextureFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_TextureFilter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureFilter___eq__" "', argument " "2"" of type '" "TextureFilter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextureFilter___eq__" "', argument " "2"" of type '" "TextureFilter const &""'"); 
  }
  arg2 = reinterpret_cast< TextureFilter * >(argp2);
  result = (bool)((TextureFilter const *)arg1)->operator ==((TextureFilter const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureFilter___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureFilter *arg1 = (TextureFilter *) 0 ;
  TextureFilter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureFilter___lt__" "', argument " "1"" of type '" "TextureFilter const *""'"); 
  }
  arg1 = reinterpret_cast< TextureFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_TextureFilter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureFilter___lt__" "', argument " "2"" of type '" "TextureFilter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextureFilter___lt__" "', argument " "2"" of type '" "TextureFilter const &""'"); 
  }
  arg2 = reinterpret_cast< TextureFilter * >(argp2);
  result = (bool)((TextureFilter const *)arg1)->operator <((TextureFilter const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureFilter_minify_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureFilter *arg1 = (TextureFilter *) 0 ;
  FilterMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureFilter_minify_set" "', argument " "1"" of type '" "TextureFilter *""'"); 
  }
  arg1 = reinterpret_cast< TextureFilter * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureFilter_minify_set" "', argument " "2"" of type '" "FilterMode""'");
  } 
  arg2 = static_cast< FilterMode >(val2);
  if (arg1) (arg1)->minify = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureFilter_minify_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureFilter *arg1 = (TextureFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FilterMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureFilter_minify_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureFilter_minify_get" "', argument " "1"" of type '" "TextureFilter *""'"); 
  }
  arg1 = reinterpret_cast< TextureFilter * >(argp1);
  result = (FilterMode) ((arg1)->minify);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_FilterMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureFilter_magnify_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureFilter *arg1 = (TextureFilter *) 0 ;
  FilterMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureFilter_magnify_set" "', argument " "1"" of type '" "TextureFilter *""'"); 
  }
  arg1 = reinterpret_cast< TextureFilter * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureFilter_magnify_set" "', argument " "2"" of type '" "FilterMode""'");
  } 
  arg2 = static_cast< FilterMode >(val2);
  if (arg1) (arg1)->magnify = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureFilter_magnify_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureFilter *arg1 = (TextureFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FilterMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureFilter_magnify_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureFilter_magnify_get" "', argument " "1"" of type '" "TextureFilter *""'"); 
  }
  arg1 = reinterpret_cast< TextureFilter * >(argp1);
  result = (FilterMode) ((arg1)->magnify);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_FilterMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureFilter_mip_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureFilter *arg1 = (TextureFilter *) 0 ;
  FilterMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureFilter_mip_set" "', argument " "1"" of type '" "TextureFilter *""'"); 
  }
  arg1 = reinterpret_cast< TextureFilter * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureFilter_mip_set" "', argument " "2"" of type '" "FilterMode""'");
  } 
  arg2 = static_cast< FilterMode >(val2);
  if (arg1) (arg1)->mip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureFilter_mip_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureFilter *arg1 = (TextureFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FilterMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureFilter_mip_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureFilter_mip_get" "', argument " "1"" of type '" "TextureFilter *""'"); 
  }
  arg1 = reinterpret_cast< TextureFilter * >(argp1);
  result = (FilterMode) ((arg1)->mip);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_FilterMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureFilter_filter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureFilter *arg1 = (TextureFilter *) 0 ;
  FilterFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureFilter_filter_set" "', argument " "1"" of type '" "TextureFilter *""'"); 
  }
  arg1 = reinterpret_cast< TextureFilter * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureFilter_filter_set" "', argument " "2"" of type '" "FilterFunction""'");
  } 
  arg2 = static_cast< FilterFunction >(val2);
  if (arg1) (arg1)->filter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureFilter_filter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureFilter *arg1 = (TextureFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FilterFunction result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureFilter_filter_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureFilter_filter_get" "', argument " "1"" of type '" "TextureFilter *""'"); 
  }
  arg1 = reinterpret_cast< TextureFilter * >(argp1);
  result = (FilterFunction) ((arg1)->filter);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_FilterFunction->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TextureFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureFilter *arg1 = (TextureFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TextureFilter",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureFilter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TextureFilter" "', argument " "1"" of type '" "TextureFilter *""'"); 
  }
  arg1 = reinterpret_cast< TextureFilter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TextureFilter) /* defines _wrap_delete_TextureFilter_destructor_closure */

SWIGINTERN int _wrap_new_TextureSwizzle4__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TextureSwizzle4 *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (TextureSwizzle4 *)new TextureSwizzle4();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureSwizzle4, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureSwizzle4__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TextureSwizzle4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TextureSwizzle4 *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TextureSwizzle4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TextureSwizzle4" "', argument " "1"" of type '" "TextureSwizzle4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TextureSwizzle4" "', argument " "1"" of type '" "TextureSwizzle4 const &""'"); 
  }
  arg1 = reinterpret_cast< TextureSwizzle4 * >(argp1);
  result = (TextureSwizzle4 *)new TextureSwizzle4((TextureSwizzle4 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureSwizzle4, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureSwizzle4(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_TextureSwizzle4",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TextureSwizzle4__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_TextureSwizzle4__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TextureSwizzle4'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TextureSwizzle4::TextureSwizzle4()\n"
    "    TextureSwizzle4::TextureSwizzle4(TextureSwizzle4 const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_TextureSwizzle4___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSwizzle4 *arg1 = (TextureSwizzle4 *) 0 ;
  TextureSwizzle4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSwizzle4___eq__" "', argument " "1"" of type '" "TextureSwizzle4 const *""'"); 
  }
  arg1 = reinterpret_cast< TextureSwizzle4 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_TextureSwizzle4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureSwizzle4___eq__" "', argument " "2"" of type '" "TextureSwizzle4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextureSwizzle4___eq__" "', argument " "2"" of type '" "TextureSwizzle4 const &""'"); 
  }
  arg2 = reinterpret_cast< TextureSwizzle4 * >(argp2);
  result = (bool)((TextureSwizzle4 const *)arg1)->operator ==((TextureSwizzle4 const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSwizzle4___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSwizzle4 *arg1 = (TextureSwizzle4 *) 0 ;
  TextureSwizzle4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSwizzle4___lt__" "', argument " "1"" of type '" "TextureSwizzle4 const *""'"); 
  }
  arg1 = reinterpret_cast< TextureSwizzle4 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_TextureSwizzle4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureSwizzle4___lt__" "', argument " "2"" of type '" "TextureSwizzle4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextureSwizzle4___lt__" "', argument " "2"" of type '" "TextureSwizzle4 const &""'"); 
  }
  arg2 = reinterpret_cast< TextureSwizzle4 * >(argp2);
  result = (bool)((TextureSwizzle4 const *)arg1)->operator <((TextureSwizzle4 const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSwizzle4_red_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSwizzle4 *arg1 = (TextureSwizzle4 *) 0 ;
  TextureSwizzle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSwizzle4_red_set" "', argument " "1"" of type '" "TextureSwizzle4 *""'"); 
  }
  arg1 = reinterpret_cast< TextureSwizzle4 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSwizzle4_red_set" "', argument " "2"" of type '" "TextureSwizzle""'");
  } 
  arg2 = static_cast< TextureSwizzle >(val2);
  if (arg1) (arg1)->red = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSwizzle4_red_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSwizzle4 *arg1 = (TextureSwizzle4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureSwizzle result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSwizzle4_red_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSwizzle4_red_get" "', argument " "1"" of type '" "TextureSwizzle4 *""'"); 
  }
  arg1 = reinterpret_cast< TextureSwizzle4 * >(argp1);
  result = (TextureSwizzle) ((arg1)->red);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_TextureSwizzle->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSwizzle4_green_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSwizzle4 *arg1 = (TextureSwizzle4 *) 0 ;
  TextureSwizzle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSwizzle4_green_set" "', argument " "1"" of type '" "TextureSwizzle4 *""'"); 
  }
  arg1 = reinterpret_cast< TextureSwizzle4 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSwizzle4_green_set" "', argument " "2"" of type '" "TextureSwizzle""'");
  } 
  arg2 = static_cast< TextureSwizzle >(val2);
  if (arg1) (arg1)->green = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSwizzle4_green_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSwizzle4 *arg1 = (TextureSwizzle4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureSwizzle result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSwizzle4_green_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSwizzle4_green_get" "', argument " "1"" of type '" "TextureSwizzle4 *""'"); 
  }
  arg1 = reinterpret_cast< TextureSwizzle4 * >(argp1);
  result = (TextureSwizzle) ((arg1)->green);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_TextureSwizzle->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSwizzle4_blue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSwizzle4 *arg1 = (TextureSwizzle4 *) 0 ;
  TextureSwizzle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSwizzle4_blue_set" "', argument " "1"" of type '" "TextureSwizzle4 *""'"); 
  }
  arg1 = reinterpret_cast< TextureSwizzle4 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSwizzle4_blue_set" "', argument " "2"" of type '" "TextureSwizzle""'");
  } 
  arg2 = static_cast< TextureSwizzle >(val2);
  if (arg1) (arg1)->blue = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSwizzle4_blue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSwizzle4 *arg1 = (TextureSwizzle4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureSwizzle result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSwizzle4_blue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSwizzle4_blue_get" "', argument " "1"" of type '" "TextureSwizzle4 *""'"); 
  }
  arg1 = reinterpret_cast< TextureSwizzle4 * >(argp1);
  result = (TextureSwizzle) ((arg1)->blue);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_TextureSwizzle->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSwizzle4_alpha_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSwizzle4 *arg1 = (TextureSwizzle4 *) 0 ;
  TextureSwizzle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSwizzle4_alpha_set" "', argument " "1"" of type '" "TextureSwizzle4 *""'"); 
  }
  arg1 = reinterpret_cast< TextureSwizzle4 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureSwizzle4_alpha_set" "', argument " "2"" of type '" "TextureSwizzle""'");
  } 
  arg2 = static_cast< TextureSwizzle >(val2);
  if (arg1) (arg1)->alpha = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureSwizzle4_alpha_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSwizzle4 *arg1 = (TextureSwizzle4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureSwizzle result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureSwizzle4_alpha_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSwizzle4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureSwizzle4_alpha_get" "', argument " "1"" of type '" "TextureSwizzle4 *""'"); 
  }
  arg1 = reinterpret_cast< TextureSwizzle4 * >(argp1);
  result = (TextureSwizzle) ((arg1)->alpha);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_TextureSwizzle->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TextureSwizzle4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSwizzle4 *arg1 = (TextureSwizzle4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TextureSwizzle4",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSwizzle4, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TextureSwizzle4" "', argument " "1"" of type '" "TextureSwizzle4 *""'"); 
  }
  arg1 = reinterpret_cast< TextureSwizzle4 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TextureSwizzle4) /* defines _wrap_delete_TextureSwizzle4_destructor_closure */

SWIGINTERN int _wrap_new_ResourceDescription__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ResourceDescription *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ResourceDescription *)new ResourceDescription();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ResourceDescription__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ResourceDescription *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ResourceDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ResourceDescription" "', argument " "1"" of type '" "ResourceDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ResourceDescription" "', argument " "1"" of type '" "ResourceDescription const &""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  result = (ResourceDescription *)new ResourceDescription((ResourceDescription const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ResourceDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ResourceDescription",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ResourceDescription__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ResourceDescription__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ResourceDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ResourceDescription::ResourceDescription()\n"
    "    ResourceDescription::ResourceDescription(ResourceDescription const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ResourceDescription___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  ResourceDescription *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription___lt__" "', argument " "1"" of type '" "ResourceDescription const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceDescription,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResourceDescription___lt__" "', argument " "2"" of type '" "ResourceDescription const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ResourceDescription___lt__" "', argument " "2"" of type '" "ResourceDescription const &""'"); 
  }
  arg2 = reinterpret_cast< ResourceDescription * >(argp2);
  result = (bool)((ResourceDescription const *)arg1)->operator <((ResourceDescription const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_resourceId_set" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResourceDescription_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceDescription_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_resourceId_get" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  ResourceType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_type_set" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceDescription_type_set" "', argument " "2"" of type '" "ResourceType""'");
  } 
  arg2 = static_cast< ResourceType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceType result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceDescription_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_type_get" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  result = (ResourceType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ResourceType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_autogeneratedName_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_autogeneratedName_set" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceDescription_autogeneratedName_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->autogeneratedName = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_autogeneratedName_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceDescription_autogeneratedName_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_autogeneratedName_get" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  result = (bool) ((arg1)->autogeneratedName);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_name_set" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ResourceDescription_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceDescription_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_name_get" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_initialisationChunks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_initialisationChunks_set" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ResourceDescription_initialisationChunks_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ResourceDescription_initialisationChunks_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->initialisationChunks = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_initialisationChunks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceDescription_initialisationChunks_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_initialisationChunks_get" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->initialisationChunks);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_derivedResources_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  rdcarray< ResourceId > *arg2 = (rdcarray< ResourceId > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_derivedResources_set" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ResourceDescription_derivedResources_set' argument 2 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ResourceDescription_derivedResources_set' argument 2 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->derivedResources = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_derivedResources_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ResourceId > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceDescription_derivedResources_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_derivedResources_get" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  result = (rdcarray< ResourceId > *)& ((arg1)->derivedResources);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ResourceId_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_parentResources_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  rdcarray< ResourceId > *arg2 = (rdcarray< ResourceId > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_parentResources_set" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ResourceDescription_parentResources_set' argument 2 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ResourceDescription_parentResources_set' argument 2 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->parentResources = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_parentResources_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ResourceId > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceDescription_parentResources_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_parentResources_get" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  result = (rdcarray< ResourceId > *)& ((arg1)->parentResources);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ResourceId_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_annotations_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  SDObject *arg2 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_annotations_set" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_SDObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResourceDescription_annotations_set" "', argument " "2"" of type '" "SDObject *""'"); 
  }
  arg2 = reinterpret_cast< SDObject * >(argp2);
  if (arg1) (arg1)->annotations = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_annotations_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceDescription_annotations_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_annotations_get" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  result = (SDObject *) ((arg1)->annotations);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription_SetCustomName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  rdcstr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription_SetCustomName" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ResourceDescription_SetCustomName' argument 2 of type 'rdcstr'"); 
    }
  }
  (arg1)->SetCustomName((rdcstr const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription___eq__" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ResourceDescription___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceDescription___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceDescription___ne__" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ResourceDescription___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResourceDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceDescription *arg1 = (ResourceDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ResourceDescription",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceDescription, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResourceDescription" "', argument " "1"" of type '" "ResourceDescription *""'"); 
  }
  arg1 = reinterpret_cast< ResourceDescription * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ResourceDescription) /* defines _wrap_delete_ResourceDescription_destructor_closure */

SWIGINTERN int _wrap_new_DescriptorStoreDescription__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  DescriptorStoreDescription *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (DescriptorStoreDescription *)new DescriptorStoreDescription();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DescriptorStoreDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DescriptorStoreDescription__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DescriptorStoreDescription *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DescriptorStoreDescription *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DescriptorStoreDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DescriptorStoreDescription" "', argument " "1"" of type '" "DescriptorStoreDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DescriptorStoreDescription" "', argument " "1"" of type '" "DescriptorStoreDescription const &""'"); 
  }
  arg1 = reinterpret_cast< DescriptorStoreDescription * >(argp1);
  result = (DescriptorStoreDescription *)new DescriptorStoreDescription((DescriptorStoreDescription const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DescriptorStoreDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DescriptorStoreDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DescriptorStoreDescription",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DescriptorStoreDescription__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_DescriptorStoreDescription__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DescriptorStoreDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DescriptorStoreDescription::DescriptorStoreDescription()\n"
    "    DescriptorStoreDescription::DescriptorStoreDescription(DescriptorStoreDescription const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_DescriptorStoreDescription___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorStoreDescription *arg1 = (DescriptorStoreDescription *) 0 ;
  DescriptorStoreDescription *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorStoreDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorStoreDescription___eq__" "', argument " "1"" of type '" "DescriptorStoreDescription const *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorStoreDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_DescriptorStoreDescription,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DescriptorStoreDescription___eq__" "', argument " "2"" of type '" "DescriptorStoreDescription const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DescriptorStoreDescription___eq__" "', argument " "2"" of type '" "DescriptorStoreDescription const &""'"); 
  }
  arg2 = reinterpret_cast< DescriptorStoreDescription * >(argp2);
  result = (bool)((DescriptorStoreDescription const *)arg1)->operator ==((DescriptorStoreDescription const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorStoreDescription___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorStoreDescription *arg1 = (DescriptorStoreDescription *) 0 ;
  DescriptorStoreDescription *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorStoreDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorStoreDescription___lt__" "', argument " "1"" of type '" "DescriptorStoreDescription const *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorStoreDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_DescriptorStoreDescription,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DescriptorStoreDescription___lt__" "', argument " "2"" of type '" "DescriptorStoreDescription const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DescriptorStoreDescription___lt__" "', argument " "2"" of type '" "DescriptorStoreDescription const &""'"); 
  }
  arg2 = reinterpret_cast< DescriptorStoreDescription * >(argp2);
  result = (bool)((DescriptorStoreDescription const *)arg1)->operator <((DescriptorStoreDescription const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorStoreDescription_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorStoreDescription *arg1 = (DescriptorStoreDescription *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorStoreDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorStoreDescription_resourceId_set" "', argument " "1"" of type '" "DescriptorStoreDescription *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorStoreDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DescriptorStoreDescription_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorStoreDescription_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorStoreDescription *arg1 = (DescriptorStoreDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorStoreDescription_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorStoreDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorStoreDescription_resourceId_get" "', argument " "1"" of type '" "DescriptorStoreDescription *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorStoreDescription * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorStoreDescription_descriptorByteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorStoreDescription *arg1 = (DescriptorStoreDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorStoreDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorStoreDescription_descriptorByteSize_set" "', argument " "1"" of type '" "DescriptorStoreDescription *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorStoreDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorStoreDescription_descriptorByteSize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->descriptorByteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorStoreDescription_descriptorByteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorStoreDescription *arg1 = (DescriptorStoreDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorStoreDescription_descriptorByteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorStoreDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorStoreDescription_descriptorByteSize_get" "', argument " "1"" of type '" "DescriptorStoreDescription *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorStoreDescription * >(argp1);
  result = (uint32_t) ((arg1)->descriptorByteSize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorStoreDescription_firstDescriptorOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorStoreDescription *arg1 = (DescriptorStoreDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorStoreDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorStoreDescription_firstDescriptorOffset_set" "', argument " "1"" of type '" "DescriptorStoreDescription *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorStoreDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorStoreDescription_firstDescriptorOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->firstDescriptorOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorStoreDescription_firstDescriptorOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorStoreDescription *arg1 = (DescriptorStoreDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorStoreDescription_firstDescriptorOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorStoreDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorStoreDescription_firstDescriptorOffset_get" "', argument " "1"" of type '" "DescriptorStoreDescription *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorStoreDescription * >(argp1);
  result = (uint32_t) ((arg1)->firstDescriptorOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorStoreDescription_descriptorCount_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorStoreDescription *arg1 = (DescriptorStoreDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorStoreDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorStoreDescription_descriptorCount_set" "', argument " "1"" of type '" "DescriptorStoreDescription *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorStoreDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DescriptorStoreDescription_descriptorCount_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->descriptorCount = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DescriptorStoreDescription_descriptorCount_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorStoreDescription *arg1 = (DescriptorStoreDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DescriptorStoreDescription_descriptorCount_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorStoreDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DescriptorStoreDescription_descriptorCount_get" "', argument " "1"" of type '" "DescriptorStoreDescription *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorStoreDescription * >(argp1);
  result = (uint32_t) ((arg1)->descriptorCount);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DescriptorStoreDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorStoreDescription *arg1 = (DescriptorStoreDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DescriptorStoreDescription",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorStoreDescription, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DescriptorStoreDescription" "', argument " "1"" of type '" "DescriptorStoreDescription *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorStoreDescription * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DescriptorStoreDescription) /* defines _wrap_delete_DescriptorStoreDescription_destructor_closure */

SWIGINTERN int _wrap_new_BufferDescription__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  BufferDescription *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (BufferDescription *)new BufferDescription();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BufferDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_BufferDescription__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BufferDescription *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  BufferDescription *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_BufferDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferDescription" "', argument " "1"" of type '" "BufferDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BufferDescription" "', argument " "1"" of type '" "BufferDescription const &""'"); 
  }
  arg1 = reinterpret_cast< BufferDescription * >(argp1);
  result = (BufferDescription *)new BufferDescription((BufferDescription const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BufferDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_BufferDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_BufferDescription",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_BufferDescription__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_BufferDescription__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BufferDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BufferDescription::BufferDescription()\n"
    "    BufferDescription::BufferDescription(BufferDescription const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_BufferDescription___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferDescription *arg1 = (BufferDescription *) 0 ;
  BufferDescription *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BufferDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferDescription___lt__" "', argument " "1"" of type '" "BufferDescription const *""'"); 
  }
  arg1 = reinterpret_cast< BufferDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_BufferDescription,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BufferDescription___lt__" "', argument " "2"" of type '" "BufferDescription const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BufferDescription___lt__" "', argument " "2"" of type '" "BufferDescription const &""'"); 
  }
  arg2 = reinterpret_cast< BufferDescription * >(argp2);
  result = (bool)((BufferDescription const *)arg1)->operator <((BufferDescription const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BufferDescription_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferDescription *arg1 = (BufferDescription *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BufferDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferDescription_resourceId_set" "', argument " "1"" of type '" "BufferDescription *""'"); 
  }
  arg1 = reinterpret_cast< BufferDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BufferDescription_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BufferDescription_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferDescription *arg1 = (BufferDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"BufferDescription_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BufferDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferDescription_resourceId_get" "', argument " "1"" of type '" "BufferDescription *""'"); 
  }
  arg1 = reinterpret_cast< BufferDescription * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BufferDescription_creationFlags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferDescription *arg1 = (BufferDescription *) 0 ;
  BufferCategory arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BufferDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferDescription_creationFlags_set" "', argument " "1"" of type '" "BufferDescription *""'"); 
  }
  arg1 = reinterpret_cast< BufferDescription * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BufferDescription_creationFlags_set" "', argument " "2"" of type '" "BufferCategory""'");
  } 
  arg2 = static_cast< BufferCategory >(val2);
  if (arg1) (arg1)->creationFlags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BufferDescription_creationFlags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferDescription *arg1 = (BufferDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BufferCategory result;
  
  if (!SWIG_Python_UnpackTuple(args,"BufferDescription_creationFlags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BufferDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferDescription_creationFlags_get" "', argument " "1"" of type '" "BufferDescription *""'"); 
  }
  arg1 = reinterpret_cast< BufferDescription * >(argp1);
  result = (BufferCategory) ((arg1)->creationFlags);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_BufferCategory->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BufferDescription_gpuAddress_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferDescription *arg1 = (BufferDescription *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BufferDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferDescription_gpuAddress_set" "', argument " "1"" of type '" "BufferDescription *""'"); 
  }
  arg1 = reinterpret_cast< BufferDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BufferDescription_gpuAddress_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->gpuAddress = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BufferDescription_gpuAddress_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferDescription *arg1 = (BufferDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"BufferDescription_gpuAddress_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BufferDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferDescription_gpuAddress_get" "', argument " "1"" of type '" "BufferDescription *""'"); 
  }
  arg1 = reinterpret_cast< BufferDescription * >(argp1);
  result = (uint64_t) ((arg1)->gpuAddress);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BufferDescription_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferDescription *arg1 = (BufferDescription *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BufferDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferDescription_length_set" "', argument " "1"" of type '" "BufferDescription *""'"); 
  }
  arg1 = reinterpret_cast< BufferDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BufferDescription_length_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BufferDescription_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferDescription *arg1 = (BufferDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"BufferDescription_length_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BufferDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferDescription_length_get" "', argument " "1"" of type '" "BufferDescription *""'"); 
  }
  arg1 = reinterpret_cast< BufferDescription * >(argp1);
  result = (uint64_t) ((arg1)->length);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BufferDescription___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferDescription *arg1 = (BufferDescription *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BufferDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferDescription___eq__" "', argument " "1"" of type '" "BufferDescription *""'"); 
  }
  arg1 = reinterpret_cast< BufferDescription * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)BufferDescription___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BufferDescription___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferDescription *arg1 = (BufferDescription *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BufferDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferDescription___ne__" "', argument " "1"" of type '" "BufferDescription *""'"); 
  }
  arg1 = reinterpret_cast< BufferDescription * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)BufferDescription___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BufferDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferDescription *arg1 = (BufferDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_BufferDescription",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BufferDescription, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BufferDescription" "', argument " "1"" of type '" "BufferDescription *""'"); 
  }
  arg1 = reinterpret_cast< BufferDescription * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_BufferDescription) /* defines _wrap_delete_BufferDescription_destructor_closure */

SWIGINTERN int _wrap_new_TextureDescription__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TextureDescription *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (TextureDescription *)new TextureDescription();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureDescription__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TextureDescription *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TextureDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TextureDescription" "', argument " "1"" of type '" "TextureDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TextureDescription" "', argument " "1"" of type '" "TextureDescription const &""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (TextureDescription *)new TextureDescription((TextureDescription const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_TextureDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_TextureDescription",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TextureDescription__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_TextureDescription__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TextureDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TextureDescription::TextureDescription()\n"
    "    TextureDescription::TextureDescription(TextureDescription const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_TextureDescription___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  TextureDescription *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription___lt__" "', argument " "1"" of type '" "TextureDescription const *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_TextureDescription,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureDescription___lt__" "', argument " "2"" of type '" "TextureDescription const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextureDescription___lt__" "', argument " "2"" of type '" "TextureDescription const &""'"); 
  }
  arg2 = reinterpret_cast< TextureDescription * >(argp2);
  result = (bool)((TextureDescription const *)arg1)->operator <((TextureDescription const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_format_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  ResourceFormat *arg2 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_format_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureDescription_format_set" "', argument " "2"" of type '" "ResourceFormat *""'"); 
  }
  arg2 = reinterpret_cast< ResourceFormat * >(argp2);
  if (arg1) (arg1)->format = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_format_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceFormat *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_format_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_format_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (ResourceFormat *)& ((arg1)->format);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_dimension_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_dimension_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDescription_dimension_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->dimension = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_dimension_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_dimension_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_dimension_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (uint32_t) ((arg1)->dimension);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  TextureType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_type_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDescription_type_set" "', argument " "2"" of type '" "TextureType""'");
  } 
  arg2 = static_cast< TextureType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureType result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_type_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (TextureType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_TextureType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_width_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDescription_width_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_width_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_width_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (uint32_t) ((arg1)->width);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_height_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDescription_height_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_height_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_height_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (uint32_t) ((arg1)->height);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_depth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_depth_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDescription_depth_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->depth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_depth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_depth_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_depth_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (uint32_t) ((arg1)->depth);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_resourceId_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureDescription_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_resourceId_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_cubemap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_cubemap_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDescription_cubemap_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->cubemap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_cubemap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_cubemap_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_cubemap_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (bool) ((arg1)->cubemap);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_mips_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_mips_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDescription_mips_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->mips = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_mips_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_mips_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_mips_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (uint32_t) ((arg1)->mips);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_arraysize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_arraysize_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDescription_arraysize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->arraysize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_arraysize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_arraysize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_arraysize_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (uint32_t) ((arg1)->arraysize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_creationFlags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  TextureCategory arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_creationFlags_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDescription_creationFlags_set" "', argument " "2"" of type '" "TextureCategory""'");
  } 
  arg2 = static_cast< TextureCategory >(val2);
  if (arg1) (arg1)->creationFlags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_creationFlags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureCategory result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_creationFlags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_creationFlags_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (TextureCategory) ((arg1)->creationFlags);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_TextureCategory->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_msQual_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_msQual_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDescription_msQual_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->msQual = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_msQual_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_msQual_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_msQual_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (uint32_t) ((arg1)->msQual);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_msSamp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_msSamp_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDescription_msSamp_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->msSamp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_msSamp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_msSamp_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_msSamp_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (uint32_t) ((arg1)->msSamp);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_byteSize_set" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextureDescription_byteSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"TextureDescription_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription_byteSize_get" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  result = (uint64_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription___eq__" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)TextureDescription___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TextureDescription___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureDescription___ne__" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)TextureDescription___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TextureDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureDescription *arg1 = (TextureDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TextureDescription",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureDescription, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TextureDescription" "', argument " "1"" of type '" "TextureDescription *""'"); 
  }
  arg1 = reinterpret_cast< TextureDescription * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TextureDescription) /* defines _wrap_delete_TextureDescription_destructor_closure */

SWIGINTERN int _wrap_new_APIEvent__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  APIEvent *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (APIEvent *)new APIEvent();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_APIEvent, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_APIEvent__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  APIEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  APIEvent *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_APIEvent,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_APIEvent" "', argument " "1"" of type '" "APIEvent const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_APIEvent" "', argument " "1"" of type '" "APIEvent const &""'"); 
  }
  arg1 = reinterpret_cast< APIEvent * >(argp1);
  result = (APIEvent *)new APIEvent((APIEvent const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_APIEvent, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_APIEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_APIEvent",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_APIEvent__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_APIEvent__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_APIEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    APIEvent::APIEvent()\n"
    "    APIEvent::APIEvent(APIEvent const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_APIEvent___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIEvent *arg1 = (APIEvent *) 0 ;
  APIEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIEvent___lt__" "', argument " "1"" of type '" "APIEvent const *""'"); 
  }
  arg1 = reinterpret_cast< APIEvent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_APIEvent,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "APIEvent___lt__" "', argument " "2"" of type '" "APIEvent const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "APIEvent___lt__" "', argument " "2"" of type '" "APIEvent const &""'"); 
  }
  arg2 = reinterpret_cast< APIEvent * >(argp2);
  result = (bool)((APIEvent const *)arg1)->operator <((APIEvent const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIEvent_eventId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIEvent *arg1 = (APIEvent *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIEvent_eventId_set" "', argument " "1"" of type '" "APIEvent *""'"); 
  }
  arg1 = reinterpret_cast< APIEvent * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "APIEvent_eventId_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->eventId = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIEvent_eventId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIEvent *arg1 = (APIEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIEvent_eventId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIEvent_eventId_get" "', argument " "1"" of type '" "APIEvent *""'"); 
  }
  arg1 = reinterpret_cast< APIEvent * >(argp1);
  result = (uint32_t) ((arg1)->eventId);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIEvent_chunkIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIEvent *arg1 = (APIEvent *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIEvent_chunkIndex_set" "', argument " "1"" of type '" "APIEvent *""'"); 
  }
  arg1 = reinterpret_cast< APIEvent * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "APIEvent_chunkIndex_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->chunkIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIEvent_chunkIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIEvent *arg1 = (APIEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIEvent_chunkIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIEvent_chunkIndex_get" "', argument " "1"" of type '" "APIEvent *""'"); 
  }
  arg1 = reinterpret_cast< APIEvent * >(argp1);
  result = (uint32_t) ((arg1)->chunkIndex);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIEvent_fileOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIEvent *arg1 = (APIEvent *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIEvent_fileOffset_set" "', argument " "1"" of type '" "APIEvent *""'"); 
  }
  arg1 = reinterpret_cast< APIEvent * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "APIEvent_fileOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->fileOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIEvent_fileOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIEvent *arg1 = (APIEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIEvent_fileOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIEvent_fileOffset_get" "', argument " "1"" of type '" "APIEvent *""'"); 
  }
  arg1 = reinterpret_cast< APIEvent * >(argp1);
  result = (uint64_t) ((arg1)->fileOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIEvent_annotations_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIEvent *arg1 = (APIEvent *) 0 ;
  SDObject *arg2 = (SDObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIEvent_annotations_set" "', argument " "1"" of type '" "APIEvent *""'"); 
  }
  arg1 = reinterpret_cast< APIEvent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_SDObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "APIEvent_annotations_set" "', argument " "2"" of type '" "SDObject *""'"); 
  }
  arg2 = reinterpret_cast< SDObject * >(argp2);
  if (arg1) (arg1)->annotations = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIEvent_annotations_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIEvent *arg1 = (APIEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SDObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"APIEvent_annotations_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIEvent_annotations_get" "', argument " "1"" of type '" "APIEvent *""'"); 
  }
  arg1 = reinterpret_cast< APIEvent * >(argp1);
  result = (SDObject *) ((arg1)->annotations);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SDObject, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIEvent___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIEvent *arg1 = (APIEvent *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIEvent___eq__" "', argument " "1"" of type '" "APIEvent *""'"); 
  }
  arg1 = reinterpret_cast< APIEvent * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)APIEvent___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIEvent___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIEvent *arg1 = (APIEvent *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIEvent___ne__" "', argument " "1"" of type '" "APIEvent *""'"); 
  }
  arg1 = reinterpret_cast< APIEvent * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)APIEvent___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_APIEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIEvent *arg1 = (APIEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_APIEvent",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIEvent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_APIEvent" "', argument " "1"" of type '" "APIEvent *""'"); 
  }
  arg1 = reinterpret_cast< APIEvent * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_APIEvent) /* defines _wrap_delete_APIEvent_destructor_closure */

SWIGINTERN int _wrap_new_DebugMessage__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  DebugMessage *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (DebugMessage *)new DebugMessage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DebugMessage, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DebugMessage__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DebugMessage *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DebugMessage,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DebugMessage" "', argument " "1"" of type '" "DebugMessage const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DebugMessage" "', argument " "1"" of type '" "DebugMessage const &""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  result = (DebugMessage *)new DebugMessage((DebugMessage const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DebugMessage, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DebugMessage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DebugMessage",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DebugMessage__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_DebugMessage__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DebugMessage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DebugMessage::DebugMessage()\n"
    "    DebugMessage::DebugMessage(DebugMessage const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_DebugMessage___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  DebugMessage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage___lt__" "', argument " "1"" of type '" "DebugMessage const *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_DebugMessage,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DebugMessage___lt__" "', argument " "2"" of type '" "DebugMessage const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DebugMessage___lt__" "', argument " "2"" of type '" "DebugMessage const &""'"); 
  }
  arg2 = reinterpret_cast< DebugMessage * >(argp2);
  result = (bool)((DebugMessage const *)arg1)->operator <((DebugMessage const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage_eventId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage_eventId_set" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DebugMessage_eventId_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->eventId = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage_eventId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DebugMessage_eventId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage_eventId_get" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  result = (uint32_t) ((arg1)->eventId);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage_category_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  MessageCategory arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage_category_set" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DebugMessage_category_set" "', argument " "2"" of type '" "MessageCategory""'");
  } 
  arg2 = static_cast< MessageCategory >(val2);
  if (arg1) (arg1)->category = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage_category_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MessageCategory result;
  
  if (!SWIG_Python_UnpackTuple(args,"DebugMessage_category_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage_category_get" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  result = (MessageCategory) ((arg1)->category);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_MessageCategory->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage_severity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  MessageSeverity arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage_severity_set" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DebugMessage_severity_set" "', argument " "2"" of type '" "MessageSeverity""'");
  } 
  arg2 = static_cast< MessageSeverity >(val2);
  if (arg1) (arg1)->severity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage_severity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MessageSeverity result;
  
  if (!SWIG_Python_UnpackTuple(args,"DebugMessage_severity_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage_severity_get" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  result = (MessageSeverity) ((arg1)->severity);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_MessageSeverity->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage_source_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  MessageSource arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage_source_set" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DebugMessage_source_set" "', argument " "2"" of type '" "MessageSource""'");
  } 
  arg2 = static_cast< MessageSource >(val2);
  if (arg1) (arg1)->source = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage_source_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MessageSource result;
  
  if (!SWIG_Python_UnpackTuple(args,"DebugMessage_source_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage_source_get" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  result = (MessageSource) ((arg1)->source);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_MessageSource->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage_messageID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage_messageID_set" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DebugMessage_messageID_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->messageID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage_messageID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DebugMessage_messageID_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage_messageID_get" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  result = (uint32_t) ((arg1)->messageID);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage_description_set" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'DebugMessage_description_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->description = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"DebugMessage_description_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage_description_get" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  result =  ((arg1)->description);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage___eq__" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)DebugMessage___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugMessage___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugMessage___ne__" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)DebugMessage___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DebugMessage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugMessage *arg1 = (DebugMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DebugMessage",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugMessage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DebugMessage" "', argument " "1"" of type '" "DebugMessage *""'"); 
  }
  arg1 = reinterpret_cast< DebugMessage * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DebugMessage) /* defines _wrap_delete_DebugMessage_destructor_closure */

SWIGINTERN int _wrap_new_BucketRecordType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BucketRecordType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_BucketRecordType",0,0,0)) SWIG_fail;
  result = (BucketRecordType *)new BucketRecordType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BucketRecordType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_BucketRecordType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BucketRecordType *arg1 = (BucketRecordType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_BucketRecordType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BucketRecordType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BucketRecordType" "', argument " "1"" of type '" "BucketRecordType *""'"); 
  }
  arg1 = reinterpret_cast< BucketRecordType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_BucketRecordType) /* defines _wrap_delete_BucketRecordType_destructor_closure */

SWIGINTERN int _wrap_new_ConstantBindStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ConstantBindStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ConstantBindStats *)new ConstantBindStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConstantBindStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ConstantBindStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ConstantBindStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ConstantBindStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantBindStats" "', argument " "1"" of type '" "ConstantBindStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBindStats" "', argument " "1"" of type '" "ConstantBindStats const &""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  result = (ConstantBindStats *)new ConstantBindStats((ConstantBindStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConstantBindStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ConstantBindStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ConstantBindStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ConstantBindStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ConstantBindStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConstantBindStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConstantBindStats::ConstantBindStats()\n"
    "    ConstantBindStats::ConstantBindStats(ConstantBindStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ConstantBindStats___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = (ConstantBindStats *) 0 ;
  ConstantBindStats *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBindStats___lt__" "', argument " "1"" of type '" "ConstantBindStats const *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ConstantBindStats,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantBindStats___lt__" "', argument " "2"" of type '" "ConstantBindStats const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantBindStats___lt__" "', argument " "2"" of type '" "ConstantBindStats const &""'"); 
  }
  arg2 = reinterpret_cast< ConstantBindStats * >(argp2);
  result = (bool)((ConstantBindStats const *)arg1)->operator <((ConstantBindStats const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBindStats___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = (ConstantBindStats *) 0 ;
  ConstantBindStats *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBindStats___eq__" "', argument " "1"" of type '" "ConstantBindStats const *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ConstantBindStats,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantBindStats___eq__" "', argument " "2"" of type '" "ConstantBindStats const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantBindStats___eq__" "', argument " "2"" of type '" "ConstantBindStats const &""'"); 
  }
  arg2 = reinterpret_cast< ConstantBindStats * >(argp2);
  result = (bool)((ConstantBindStats const *)arg1)->operator ==((ConstantBindStats const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBindStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = (ConstantBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBindStats_calls_set" "', argument " "1"" of type '" "ConstantBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstantBindStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBindStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = (ConstantBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBindStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBindStats_calls_get" "', argument " "1"" of type '" "ConstantBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBindStats_sets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = (ConstantBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBindStats_sets_set" "', argument " "1"" of type '" "ConstantBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstantBindStats_sets_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sets = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBindStats_sets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = (ConstantBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBindStats_sets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBindStats_sets_get" "', argument " "1"" of type '" "ConstantBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  result = (uint32_t) ((arg1)->sets);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBindStats_nulls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = (ConstantBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBindStats_nulls_set" "', argument " "1"" of type '" "ConstantBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstantBindStats_nulls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->nulls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBindStats_nulls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = (ConstantBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBindStats_nulls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBindStats_nulls_get" "', argument " "1"" of type '" "ConstantBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  result = (uint32_t) ((arg1)->nulls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBindStats_bindslots_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = (ConstantBindStats *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBindStats_bindslots_set" "', argument " "1"" of type '" "ConstantBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ConstantBindStats_bindslots_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ConstantBindStats_bindslots_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->bindslots = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBindStats_bindslots_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = (ConstantBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBindStats_bindslots_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBindStats_bindslots_get" "', argument " "1"" of type '" "ConstantBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->bindslots);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBindStats_sizes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = (ConstantBindStats *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBindStats_sizes_set" "', argument " "1"" of type '" "ConstantBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ConstantBindStats_sizes_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ConstantBindStats_sizes_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->sizes = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBindStats_sizes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = (ConstantBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBindStats_sizes_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBindStats_sizes_get" "', argument " "1"" of type '" "ConstantBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->sizes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ConstantBindStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBindStats *arg1 = (ConstantBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ConstantBindStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBindStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstantBindStats" "', argument " "1"" of type '" "ConstantBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBindStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ConstantBindStats) /* defines _wrap_delete_ConstantBindStats_destructor_closure */

SWIGINTERN int _wrap_new_SamplerBindStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SamplerBindStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SamplerBindStats *)new SamplerBindStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SamplerBindStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_SamplerBindStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerBindStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SamplerBindStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerBindStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SamplerBindStats" "', argument " "1"" of type '" "SamplerBindStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SamplerBindStats" "', argument " "1"" of type '" "SamplerBindStats const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerBindStats * >(argp1);
  result = (SamplerBindStats *)new SamplerBindStats((SamplerBindStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SamplerBindStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_SamplerBindStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SamplerBindStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SamplerBindStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_SamplerBindStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SamplerBindStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SamplerBindStats::SamplerBindStats()\n"
    "    SamplerBindStats::SamplerBindStats(SamplerBindStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_SamplerBindStats___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerBindStats *arg1 = (SamplerBindStats *) 0 ;
  SamplerBindStats *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerBindStats___lt__" "', argument " "1"" of type '" "SamplerBindStats const *""'"); 
  }
  arg1 = reinterpret_cast< SamplerBindStats * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_SamplerBindStats,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SamplerBindStats___lt__" "', argument " "2"" of type '" "SamplerBindStats const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SamplerBindStats___lt__" "', argument " "2"" of type '" "SamplerBindStats const &""'"); 
  }
  arg2 = reinterpret_cast< SamplerBindStats * >(argp2);
  result = (bool)((SamplerBindStats const *)arg1)->operator <((SamplerBindStats const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerBindStats___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerBindStats *arg1 = (SamplerBindStats *) 0 ;
  SamplerBindStats *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerBindStats___eq__" "', argument " "1"" of type '" "SamplerBindStats const *""'"); 
  }
  arg1 = reinterpret_cast< SamplerBindStats * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_SamplerBindStats,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SamplerBindStats___eq__" "', argument " "2"" of type '" "SamplerBindStats const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SamplerBindStats___eq__" "', argument " "2"" of type '" "SamplerBindStats const &""'"); 
  }
  arg2 = reinterpret_cast< SamplerBindStats * >(argp2);
  result = (bool)((SamplerBindStats const *)arg1)->operator ==((SamplerBindStats const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerBindStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerBindStats *arg1 = (SamplerBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerBindStats_calls_set" "', argument " "1"" of type '" "SamplerBindStats *""'"); 
  }
  arg1 = reinterpret_cast< SamplerBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerBindStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerBindStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerBindStats *arg1 = (SamplerBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerBindStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerBindStats_calls_get" "', argument " "1"" of type '" "SamplerBindStats *""'"); 
  }
  arg1 = reinterpret_cast< SamplerBindStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerBindStats_sets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerBindStats *arg1 = (SamplerBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerBindStats_sets_set" "', argument " "1"" of type '" "SamplerBindStats *""'"); 
  }
  arg1 = reinterpret_cast< SamplerBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerBindStats_sets_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sets = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerBindStats_sets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerBindStats *arg1 = (SamplerBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerBindStats_sets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerBindStats_sets_get" "', argument " "1"" of type '" "SamplerBindStats *""'"); 
  }
  arg1 = reinterpret_cast< SamplerBindStats * >(argp1);
  result = (uint32_t) ((arg1)->sets);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerBindStats_nulls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerBindStats *arg1 = (SamplerBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerBindStats_nulls_set" "', argument " "1"" of type '" "SamplerBindStats *""'"); 
  }
  arg1 = reinterpret_cast< SamplerBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SamplerBindStats_nulls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->nulls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerBindStats_nulls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerBindStats *arg1 = (SamplerBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerBindStats_nulls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerBindStats_nulls_get" "', argument " "1"" of type '" "SamplerBindStats *""'"); 
  }
  arg1 = reinterpret_cast< SamplerBindStats * >(argp1);
  result = (uint32_t) ((arg1)->nulls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerBindStats_bindslots_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerBindStats *arg1 = (SamplerBindStats *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerBindStats_bindslots_set" "', argument " "1"" of type '" "SamplerBindStats *""'"); 
  }
  arg1 = reinterpret_cast< SamplerBindStats * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'SamplerBindStats_bindslots_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'SamplerBindStats_bindslots_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->bindslots = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplerBindStats_bindslots_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerBindStats *arg1 = (SamplerBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SamplerBindStats_bindslots_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplerBindStats_bindslots_get" "', argument " "1"" of type '" "SamplerBindStats *""'"); 
  }
  arg1 = reinterpret_cast< SamplerBindStats * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->bindslots);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SamplerBindStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerBindStats *arg1 = (SamplerBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_SamplerBindStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SamplerBindStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SamplerBindStats" "', argument " "1"" of type '" "SamplerBindStats *""'"); 
  }
  arg1 = reinterpret_cast< SamplerBindStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_SamplerBindStats) /* defines _wrap_delete_SamplerBindStats_destructor_closure */

SWIGINTERN int _wrap_new_ResourceBindStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ResourceBindStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ResourceBindStats *)new ResourceBindStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceBindStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ResourceBindStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ResourceBindStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ResourceBindStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ResourceBindStats" "', argument " "1"" of type '" "ResourceBindStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ResourceBindStats" "', argument " "1"" of type '" "ResourceBindStats const &""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  result = (ResourceBindStats *)new ResourceBindStats((ResourceBindStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceBindStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ResourceBindStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ResourceBindStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ResourceBindStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ResourceBindStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ResourceBindStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ResourceBindStats::ResourceBindStats()\n"
    "    ResourceBindStats::ResourceBindStats(ResourceBindStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ResourceBindStats___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = (ResourceBindStats *) 0 ;
  ResourceBindStats *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceBindStats___lt__" "', argument " "1"" of type '" "ResourceBindStats const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceBindStats,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResourceBindStats___lt__" "', argument " "2"" of type '" "ResourceBindStats const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ResourceBindStats___lt__" "', argument " "2"" of type '" "ResourceBindStats const &""'"); 
  }
  arg2 = reinterpret_cast< ResourceBindStats * >(argp2);
  result = (bool)((ResourceBindStats const *)arg1)->operator <((ResourceBindStats const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceBindStats___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = (ResourceBindStats *) 0 ;
  ResourceBindStats *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceBindStats___eq__" "', argument " "1"" of type '" "ResourceBindStats const *""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceBindStats,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResourceBindStats___eq__" "', argument " "2"" of type '" "ResourceBindStats const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ResourceBindStats___eq__" "', argument " "2"" of type '" "ResourceBindStats const &""'"); 
  }
  arg2 = reinterpret_cast< ResourceBindStats * >(argp2);
  result = (bool)((ResourceBindStats const *)arg1)->operator ==((ResourceBindStats const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceBindStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = (ResourceBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceBindStats_calls_set" "', argument " "1"" of type '" "ResourceBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceBindStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceBindStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = (ResourceBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceBindStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceBindStats_calls_get" "', argument " "1"" of type '" "ResourceBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceBindStats_sets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = (ResourceBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceBindStats_sets_set" "', argument " "1"" of type '" "ResourceBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceBindStats_sets_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sets = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceBindStats_sets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = (ResourceBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceBindStats_sets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceBindStats_sets_get" "', argument " "1"" of type '" "ResourceBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  result = (uint32_t) ((arg1)->sets);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceBindStats_nulls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = (ResourceBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceBindStats_nulls_set" "', argument " "1"" of type '" "ResourceBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceBindStats_nulls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->nulls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceBindStats_nulls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = (ResourceBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceBindStats_nulls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceBindStats_nulls_get" "', argument " "1"" of type '" "ResourceBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  result = (uint32_t) ((arg1)->nulls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceBindStats_types_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = (ResourceBindStats *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceBindStats_types_set" "', argument " "1"" of type '" "ResourceBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ResourceBindStats_types_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ResourceBindStats_types_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->types = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceBindStats_types_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = (ResourceBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceBindStats_types_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceBindStats_types_get" "', argument " "1"" of type '" "ResourceBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->types);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceBindStats_bindslots_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = (ResourceBindStats *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceBindStats_bindslots_set" "', argument " "1"" of type '" "ResourceBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ResourceBindStats_bindslots_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ResourceBindStats_bindslots_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->bindslots = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceBindStats_bindslots_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = (ResourceBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceBindStats_bindslots_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceBindStats_bindslots_get" "', argument " "1"" of type '" "ResourceBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->bindslots);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResourceBindStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceBindStats *arg1 = (ResourceBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ResourceBindStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceBindStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResourceBindStats" "', argument " "1"" of type '" "ResourceBindStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceBindStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ResourceBindStats) /* defines _wrap_delete_ResourceBindStats_destructor_closure */

SWIGINTERN int _wrap_new_ResourceUpdateStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ResourceUpdateStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ResourceUpdateStats *)new ResourceUpdateStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceUpdateStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ResourceUpdateStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ResourceUpdateStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ResourceUpdateStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ResourceUpdateStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ResourceUpdateStats" "', argument " "1"" of type '" "ResourceUpdateStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ResourceUpdateStats" "', argument " "1"" of type '" "ResourceUpdateStats const &""'"); 
  }
  arg1 = reinterpret_cast< ResourceUpdateStats * >(argp1);
  result = (ResourceUpdateStats *)new ResourceUpdateStats((ResourceUpdateStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceUpdateStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ResourceUpdateStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ResourceUpdateStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ResourceUpdateStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ResourceUpdateStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ResourceUpdateStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ResourceUpdateStats::ResourceUpdateStats()\n"
    "    ResourceUpdateStats::ResourceUpdateStats(ResourceUpdateStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ResourceUpdateStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceUpdateStats *arg1 = (ResourceUpdateStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceUpdateStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceUpdateStats_calls_set" "', argument " "1"" of type '" "ResourceUpdateStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceUpdateStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceUpdateStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceUpdateStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceUpdateStats *arg1 = (ResourceUpdateStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceUpdateStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceUpdateStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceUpdateStats_calls_get" "', argument " "1"" of type '" "ResourceUpdateStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceUpdateStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceUpdateStats_clients_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceUpdateStats *arg1 = (ResourceUpdateStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceUpdateStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceUpdateStats_clients_set" "', argument " "1"" of type '" "ResourceUpdateStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceUpdateStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceUpdateStats_clients_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->clients = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceUpdateStats_clients_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceUpdateStats *arg1 = (ResourceUpdateStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceUpdateStats_clients_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceUpdateStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceUpdateStats_clients_get" "', argument " "1"" of type '" "ResourceUpdateStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceUpdateStats * >(argp1);
  result = (uint32_t) ((arg1)->clients);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceUpdateStats_servers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceUpdateStats *arg1 = (ResourceUpdateStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceUpdateStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceUpdateStats_servers_set" "', argument " "1"" of type '" "ResourceUpdateStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceUpdateStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResourceUpdateStats_servers_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->servers = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceUpdateStats_servers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceUpdateStats *arg1 = (ResourceUpdateStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceUpdateStats_servers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceUpdateStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceUpdateStats_servers_get" "', argument " "1"" of type '" "ResourceUpdateStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceUpdateStats * >(argp1);
  result = (uint32_t) ((arg1)->servers);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceUpdateStats_types_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceUpdateStats *arg1 = (ResourceUpdateStats *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceUpdateStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceUpdateStats_types_set" "', argument " "1"" of type '" "ResourceUpdateStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceUpdateStats * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ResourceUpdateStats_types_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ResourceUpdateStats_types_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->types = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceUpdateStats_types_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceUpdateStats *arg1 = (ResourceUpdateStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceUpdateStats_types_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceUpdateStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceUpdateStats_types_get" "', argument " "1"" of type '" "ResourceUpdateStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceUpdateStats * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->types);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceUpdateStats_sizes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceUpdateStats *arg1 = (ResourceUpdateStats *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceUpdateStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceUpdateStats_sizes_set" "', argument " "1"" of type '" "ResourceUpdateStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceUpdateStats * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ResourceUpdateStats_sizes_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ResourceUpdateStats_sizes_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->sizes = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResourceUpdateStats_sizes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceUpdateStats *arg1 = (ResourceUpdateStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ResourceUpdateStats_sizes_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceUpdateStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResourceUpdateStats_sizes_get" "', argument " "1"" of type '" "ResourceUpdateStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceUpdateStats * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->sizes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResourceUpdateStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceUpdateStats *arg1 = (ResourceUpdateStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ResourceUpdateStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceUpdateStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResourceUpdateStats" "', argument " "1"" of type '" "ResourceUpdateStats *""'"); 
  }
  arg1 = reinterpret_cast< ResourceUpdateStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ResourceUpdateStats) /* defines _wrap_delete_ResourceUpdateStats_destructor_closure */

SWIGINTERN int _wrap_new_DrawcallStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  DrawcallStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (DrawcallStats *)new DrawcallStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DrawcallStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DrawcallStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DrawcallStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DrawcallStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DrawcallStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DrawcallStats" "', argument " "1"" of type '" "DrawcallStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DrawcallStats" "', argument " "1"" of type '" "DrawcallStats const &""'"); 
  }
  arg1 = reinterpret_cast< DrawcallStats * >(argp1);
  result = (DrawcallStats *)new DrawcallStats((DrawcallStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DrawcallStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DrawcallStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DrawcallStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DrawcallStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_DrawcallStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DrawcallStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DrawcallStats::DrawcallStats()\n"
    "    DrawcallStats::DrawcallStats(DrawcallStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_DrawcallStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DrawcallStats *arg1 = (DrawcallStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DrawcallStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawcallStats_calls_set" "', argument " "1"" of type '" "DrawcallStats *""'"); 
  }
  arg1 = reinterpret_cast< DrawcallStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DrawcallStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DrawcallStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DrawcallStats *arg1 = (DrawcallStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DrawcallStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DrawcallStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawcallStats_calls_get" "', argument " "1"" of type '" "DrawcallStats *""'"); 
  }
  arg1 = reinterpret_cast< DrawcallStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DrawcallStats_instanced_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DrawcallStats *arg1 = (DrawcallStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DrawcallStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawcallStats_instanced_set" "', argument " "1"" of type '" "DrawcallStats *""'"); 
  }
  arg1 = reinterpret_cast< DrawcallStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DrawcallStats_instanced_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->instanced = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DrawcallStats_instanced_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DrawcallStats *arg1 = (DrawcallStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DrawcallStats_instanced_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DrawcallStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawcallStats_instanced_get" "', argument " "1"" of type '" "DrawcallStats *""'"); 
  }
  arg1 = reinterpret_cast< DrawcallStats * >(argp1);
  result = (uint32_t) ((arg1)->instanced);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DrawcallStats_indirect_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DrawcallStats *arg1 = (DrawcallStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DrawcallStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawcallStats_indirect_set" "', argument " "1"" of type '" "DrawcallStats *""'"); 
  }
  arg1 = reinterpret_cast< DrawcallStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DrawcallStats_indirect_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->indirect = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DrawcallStats_indirect_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DrawcallStats *arg1 = (DrawcallStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DrawcallStats_indirect_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DrawcallStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawcallStats_indirect_get" "', argument " "1"" of type '" "DrawcallStats *""'"); 
  }
  arg1 = reinterpret_cast< DrawcallStats * >(argp1);
  result = (uint32_t) ((arg1)->indirect);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DrawcallStats_counts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DrawcallStats *arg1 = (DrawcallStats *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DrawcallStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawcallStats_counts_set" "', argument " "1"" of type '" "DrawcallStats *""'"); 
  }
  arg1 = reinterpret_cast< DrawcallStats * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'DrawcallStats_counts_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'DrawcallStats_counts_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->counts = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_DrawcallStats_counts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DrawcallStats *arg1 = (DrawcallStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"DrawcallStats_counts_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DrawcallStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawcallStats_counts_get" "', argument " "1"" of type '" "DrawcallStats *""'"); 
  }
  arg1 = reinterpret_cast< DrawcallStats * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->counts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DrawcallStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DrawcallStats *arg1 = (DrawcallStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DrawcallStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DrawcallStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DrawcallStats" "', argument " "1"" of type '" "DrawcallStats *""'"); 
  }
  arg1 = reinterpret_cast< DrawcallStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DrawcallStats) /* defines _wrap_delete_DrawcallStats_destructor_closure */

SWIGINTERN int _wrap_new_DispatchStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  DispatchStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (DispatchStats *)new DispatchStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DispatchStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DispatchStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DispatchStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DispatchStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DispatchStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DispatchStats" "', argument " "1"" of type '" "DispatchStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DispatchStats" "', argument " "1"" of type '" "DispatchStats const &""'"); 
  }
  arg1 = reinterpret_cast< DispatchStats * >(argp1);
  result = (DispatchStats *)new DispatchStats((DispatchStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DispatchStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DispatchStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DispatchStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DispatchStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_DispatchStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DispatchStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DispatchStats::DispatchStats()\n"
    "    DispatchStats::DispatchStats(DispatchStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_DispatchStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DispatchStats *arg1 = (DispatchStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DispatchStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DispatchStats_calls_set" "', argument " "1"" of type '" "DispatchStats *""'"); 
  }
  arg1 = reinterpret_cast< DispatchStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DispatchStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DispatchStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DispatchStats *arg1 = (DispatchStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DispatchStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DispatchStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DispatchStats_calls_get" "', argument " "1"" of type '" "DispatchStats *""'"); 
  }
  arg1 = reinterpret_cast< DispatchStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DispatchStats_indirect_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DispatchStats *arg1 = (DispatchStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DispatchStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DispatchStats_indirect_set" "', argument " "1"" of type '" "DispatchStats *""'"); 
  }
  arg1 = reinterpret_cast< DispatchStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DispatchStats_indirect_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->indirect = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DispatchStats_indirect_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DispatchStats *arg1 = (DispatchStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DispatchStats_indirect_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DispatchStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DispatchStats_indirect_get" "', argument " "1"" of type '" "DispatchStats *""'"); 
  }
  arg1 = reinterpret_cast< DispatchStats * >(argp1);
  result = (uint32_t) ((arg1)->indirect);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DispatchStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DispatchStats *arg1 = (DispatchStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DispatchStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DispatchStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DispatchStats" "', argument " "1"" of type '" "DispatchStats *""'"); 
  }
  arg1 = reinterpret_cast< DispatchStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DispatchStats) /* defines _wrap_delete_DispatchStats_destructor_closure */

SWIGINTERN int _wrap_new_IndexBindStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  IndexBindStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (IndexBindStats *)new IndexBindStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IndexBindStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_IndexBindStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IndexBindStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  IndexBindStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_IndexBindStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IndexBindStats" "', argument " "1"" of type '" "IndexBindStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IndexBindStats" "', argument " "1"" of type '" "IndexBindStats const &""'"); 
  }
  arg1 = reinterpret_cast< IndexBindStats * >(argp1);
  result = (IndexBindStats *)new IndexBindStats((IndexBindStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IndexBindStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_IndexBindStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_IndexBindStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_IndexBindStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_IndexBindStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IndexBindStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IndexBindStats::IndexBindStats()\n"
    "    IndexBindStats::IndexBindStats(IndexBindStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_IndexBindStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexBindStats *arg1 = (IndexBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IndexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexBindStats_calls_set" "', argument " "1"" of type '" "IndexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< IndexBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndexBindStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexBindStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexBindStats *arg1 = (IndexBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"IndexBindStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IndexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexBindStats_calls_get" "', argument " "1"" of type '" "IndexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< IndexBindStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexBindStats_sets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexBindStats *arg1 = (IndexBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IndexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexBindStats_sets_set" "', argument " "1"" of type '" "IndexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< IndexBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndexBindStats_sets_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sets = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexBindStats_sets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexBindStats *arg1 = (IndexBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"IndexBindStats_sets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IndexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexBindStats_sets_get" "', argument " "1"" of type '" "IndexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< IndexBindStats * >(argp1);
  result = (uint32_t) ((arg1)->sets);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexBindStats_nulls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexBindStats *arg1 = (IndexBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IndexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexBindStats_nulls_set" "', argument " "1"" of type '" "IndexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< IndexBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndexBindStats_nulls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->nulls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexBindStats_nulls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexBindStats *arg1 = (IndexBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"IndexBindStats_nulls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IndexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexBindStats_nulls_get" "', argument " "1"" of type '" "IndexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< IndexBindStats * >(argp1);
  result = (uint32_t) ((arg1)->nulls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IndexBindStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexBindStats *arg1 = (IndexBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_IndexBindStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_IndexBindStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IndexBindStats" "', argument " "1"" of type '" "IndexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< IndexBindStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_IndexBindStats) /* defines _wrap_delete_IndexBindStats_destructor_closure */

SWIGINTERN int _wrap_new_VertexBindStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VertexBindStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VertexBindStats *)new VertexBindStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VertexBindStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VertexBindStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VertexBindStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VertexBindStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VertexBindStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VertexBindStats" "', argument " "1"" of type '" "VertexBindStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VertexBindStats" "', argument " "1"" of type '" "VertexBindStats const &""'"); 
  }
  arg1 = reinterpret_cast< VertexBindStats * >(argp1);
  result = (VertexBindStats *)new VertexBindStats((VertexBindStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VertexBindStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VertexBindStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VertexBindStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VertexBindStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VertexBindStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VertexBindStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VertexBindStats::VertexBindStats()\n"
    "    VertexBindStats::VertexBindStats(VertexBindStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VertexBindStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexBindStats *arg1 = (VertexBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexBindStats_calls_set" "', argument " "1"" of type '" "VertexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< VertexBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VertexBindStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexBindStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexBindStats *arg1 = (VertexBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexBindStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexBindStats_calls_get" "', argument " "1"" of type '" "VertexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< VertexBindStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexBindStats_sets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexBindStats *arg1 = (VertexBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexBindStats_sets_set" "', argument " "1"" of type '" "VertexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< VertexBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VertexBindStats_sets_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sets = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexBindStats_sets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexBindStats *arg1 = (VertexBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexBindStats_sets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexBindStats_sets_get" "', argument " "1"" of type '" "VertexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< VertexBindStats * >(argp1);
  result = (uint32_t) ((arg1)->sets);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexBindStats_nulls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexBindStats *arg1 = (VertexBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexBindStats_nulls_set" "', argument " "1"" of type '" "VertexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< VertexBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VertexBindStats_nulls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->nulls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexBindStats_nulls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexBindStats *arg1 = (VertexBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexBindStats_nulls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexBindStats_nulls_get" "', argument " "1"" of type '" "VertexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< VertexBindStats * >(argp1);
  result = (uint32_t) ((arg1)->nulls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexBindStats_bindslots_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexBindStats *arg1 = (VertexBindStats *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexBindStats_bindslots_set" "', argument " "1"" of type '" "VertexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< VertexBindStats * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VertexBindStats_bindslots_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VertexBindStats_bindslots_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->bindslots = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VertexBindStats_bindslots_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexBindStats *arg1 = (VertexBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VertexBindStats_bindslots_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexBindStats_bindslots_get" "', argument " "1"" of type '" "VertexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< VertexBindStats * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->bindslots);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VertexBindStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VertexBindStats *arg1 = (VertexBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VertexBindStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VertexBindStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VertexBindStats" "', argument " "1"" of type '" "VertexBindStats *""'"); 
  }
  arg1 = reinterpret_cast< VertexBindStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VertexBindStats) /* defines _wrap_delete_VertexBindStats_destructor_closure */

SWIGINTERN int _wrap_new_LayoutBindStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  LayoutBindStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (LayoutBindStats *)new LayoutBindStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LayoutBindStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_LayoutBindStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LayoutBindStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  LayoutBindStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_LayoutBindStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LayoutBindStats" "', argument " "1"" of type '" "LayoutBindStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LayoutBindStats" "', argument " "1"" of type '" "LayoutBindStats const &""'"); 
  }
  arg1 = reinterpret_cast< LayoutBindStats * >(argp1);
  result = (LayoutBindStats *)new LayoutBindStats((LayoutBindStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LayoutBindStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_LayoutBindStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_LayoutBindStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_LayoutBindStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_LayoutBindStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LayoutBindStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LayoutBindStats::LayoutBindStats()\n"
    "    LayoutBindStats::LayoutBindStats(LayoutBindStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_LayoutBindStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LayoutBindStats *arg1 = (LayoutBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LayoutBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutBindStats_calls_set" "', argument " "1"" of type '" "LayoutBindStats *""'"); 
  }
  arg1 = reinterpret_cast< LayoutBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LayoutBindStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LayoutBindStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LayoutBindStats *arg1 = (LayoutBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"LayoutBindStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LayoutBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutBindStats_calls_get" "', argument " "1"" of type '" "LayoutBindStats *""'"); 
  }
  arg1 = reinterpret_cast< LayoutBindStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LayoutBindStats_sets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LayoutBindStats *arg1 = (LayoutBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LayoutBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutBindStats_sets_set" "', argument " "1"" of type '" "LayoutBindStats *""'"); 
  }
  arg1 = reinterpret_cast< LayoutBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LayoutBindStats_sets_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sets = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LayoutBindStats_sets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LayoutBindStats *arg1 = (LayoutBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"LayoutBindStats_sets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LayoutBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutBindStats_sets_get" "', argument " "1"" of type '" "LayoutBindStats *""'"); 
  }
  arg1 = reinterpret_cast< LayoutBindStats * >(argp1);
  result = (uint32_t) ((arg1)->sets);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LayoutBindStats_nulls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LayoutBindStats *arg1 = (LayoutBindStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LayoutBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutBindStats_nulls_set" "', argument " "1"" of type '" "LayoutBindStats *""'"); 
  }
  arg1 = reinterpret_cast< LayoutBindStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LayoutBindStats_nulls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->nulls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LayoutBindStats_nulls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LayoutBindStats *arg1 = (LayoutBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"LayoutBindStats_nulls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LayoutBindStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutBindStats_nulls_get" "', argument " "1"" of type '" "LayoutBindStats *""'"); 
  }
  arg1 = reinterpret_cast< LayoutBindStats * >(argp1);
  result = (uint32_t) ((arg1)->nulls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LayoutBindStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LayoutBindStats *arg1 = (LayoutBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_LayoutBindStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LayoutBindStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutBindStats" "', argument " "1"" of type '" "LayoutBindStats *""'"); 
  }
  arg1 = reinterpret_cast< LayoutBindStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_LayoutBindStats) /* defines _wrap_delete_LayoutBindStats_destructor_closure */

SWIGINTERN int _wrap_new_ShaderChangeStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderChangeStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderChangeStats *)new ShaderChangeStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderChangeStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderChangeStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderChangeStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderChangeStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderChangeStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderChangeStats" "', argument " "1"" of type '" "ShaderChangeStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderChangeStats" "', argument " "1"" of type '" "ShaderChangeStats const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderChangeStats * >(argp1);
  result = (ShaderChangeStats *)new ShaderChangeStats((ShaderChangeStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderChangeStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderChangeStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderChangeStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderChangeStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderChangeStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderChangeStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderChangeStats::ShaderChangeStats()\n"
    "    ShaderChangeStats::ShaderChangeStats(ShaderChangeStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderChangeStats___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderChangeStats *arg1 = (ShaderChangeStats *) 0 ;
  ShaderChangeStats *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderChangeStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderChangeStats___lt__" "', argument " "1"" of type '" "ShaderChangeStats const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderChangeStats * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderChangeStats,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderChangeStats___lt__" "', argument " "2"" of type '" "ShaderChangeStats const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderChangeStats___lt__" "', argument " "2"" of type '" "ShaderChangeStats const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderChangeStats * >(argp2);
  result = (bool)((ShaderChangeStats const *)arg1)->operator <((ShaderChangeStats const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderChangeStats___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderChangeStats *arg1 = (ShaderChangeStats *) 0 ;
  ShaderChangeStats *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderChangeStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderChangeStats___eq__" "', argument " "1"" of type '" "ShaderChangeStats const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderChangeStats * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderChangeStats,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderChangeStats___eq__" "', argument " "2"" of type '" "ShaderChangeStats const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderChangeStats___eq__" "', argument " "2"" of type '" "ShaderChangeStats const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderChangeStats * >(argp2);
  result = (bool)((ShaderChangeStats const *)arg1)->operator ==((ShaderChangeStats const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderChangeStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderChangeStats *arg1 = (ShaderChangeStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderChangeStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderChangeStats_calls_set" "', argument " "1"" of type '" "ShaderChangeStats *""'"); 
  }
  arg1 = reinterpret_cast< ShaderChangeStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderChangeStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderChangeStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderChangeStats *arg1 = (ShaderChangeStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderChangeStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderChangeStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderChangeStats_calls_get" "', argument " "1"" of type '" "ShaderChangeStats *""'"); 
  }
  arg1 = reinterpret_cast< ShaderChangeStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderChangeStats_sets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderChangeStats *arg1 = (ShaderChangeStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderChangeStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderChangeStats_sets_set" "', argument " "1"" of type '" "ShaderChangeStats *""'"); 
  }
  arg1 = reinterpret_cast< ShaderChangeStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderChangeStats_sets_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sets = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderChangeStats_sets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderChangeStats *arg1 = (ShaderChangeStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderChangeStats_sets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderChangeStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderChangeStats_sets_get" "', argument " "1"" of type '" "ShaderChangeStats *""'"); 
  }
  arg1 = reinterpret_cast< ShaderChangeStats * >(argp1);
  result = (uint32_t) ((arg1)->sets);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderChangeStats_nulls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderChangeStats *arg1 = (ShaderChangeStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderChangeStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderChangeStats_nulls_set" "', argument " "1"" of type '" "ShaderChangeStats *""'"); 
  }
  arg1 = reinterpret_cast< ShaderChangeStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderChangeStats_nulls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->nulls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderChangeStats_nulls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderChangeStats *arg1 = (ShaderChangeStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderChangeStats_nulls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderChangeStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderChangeStats_nulls_get" "', argument " "1"" of type '" "ShaderChangeStats *""'"); 
  }
  arg1 = reinterpret_cast< ShaderChangeStats * >(argp1);
  result = (uint32_t) ((arg1)->nulls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderChangeStats_redundants_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderChangeStats *arg1 = (ShaderChangeStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderChangeStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderChangeStats_redundants_set" "', argument " "1"" of type '" "ShaderChangeStats *""'"); 
  }
  arg1 = reinterpret_cast< ShaderChangeStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderChangeStats_redundants_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->redundants = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderChangeStats_redundants_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderChangeStats *arg1 = (ShaderChangeStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderChangeStats_redundants_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderChangeStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderChangeStats_redundants_get" "', argument " "1"" of type '" "ShaderChangeStats *""'"); 
  }
  arg1 = reinterpret_cast< ShaderChangeStats * >(argp1);
  result = (uint32_t) ((arg1)->redundants);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderChangeStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderChangeStats *arg1 = (ShaderChangeStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderChangeStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderChangeStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderChangeStats" "', argument " "1"" of type '" "ShaderChangeStats *""'"); 
  }
  arg1 = reinterpret_cast< ShaderChangeStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderChangeStats) /* defines _wrap_delete_ShaderChangeStats_destructor_closure */

SWIGINTERN int _wrap_new_BlendStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  BlendStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (BlendStats *)new BlendStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BlendStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_BlendStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlendStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  BlendStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_BlendStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlendStats" "', argument " "1"" of type '" "BlendStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlendStats" "', argument " "1"" of type '" "BlendStats const &""'"); 
  }
  arg1 = reinterpret_cast< BlendStats * >(argp1);
  result = (BlendStats *)new BlendStats((BlendStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BlendStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_BlendStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_BlendStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_BlendStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_BlendStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BlendStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlendStats::BlendStats()\n"
    "    BlendStats::BlendStats(BlendStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_BlendStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendStats *arg1 = (BlendStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendStats_calls_set" "', argument " "1"" of type '" "BlendStats *""'"); 
  }
  arg1 = reinterpret_cast< BlendStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlendStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendStats *arg1 = (BlendStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"BlendStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendStats_calls_get" "', argument " "1"" of type '" "BlendStats *""'"); 
  }
  arg1 = reinterpret_cast< BlendStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendStats_sets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendStats *arg1 = (BlendStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendStats_sets_set" "', argument " "1"" of type '" "BlendStats *""'"); 
  }
  arg1 = reinterpret_cast< BlendStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlendStats_sets_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sets = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendStats_sets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendStats *arg1 = (BlendStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"BlendStats_sets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendStats_sets_get" "', argument " "1"" of type '" "BlendStats *""'"); 
  }
  arg1 = reinterpret_cast< BlendStats * >(argp1);
  result = (uint32_t) ((arg1)->sets);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendStats_nulls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendStats *arg1 = (BlendStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendStats_nulls_set" "', argument " "1"" of type '" "BlendStats *""'"); 
  }
  arg1 = reinterpret_cast< BlendStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlendStats_nulls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->nulls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendStats_nulls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendStats *arg1 = (BlendStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"BlendStats_nulls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendStats_nulls_get" "', argument " "1"" of type '" "BlendStats *""'"); 
  }
  arg1 = reinterpret_cast< BlendStats * >(argp1);
  result = (uint32_t) ((arg1)->nulls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendStats_redundants_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendStats *arg1 = (BlendStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendStats_redundants_set" "', argument " "1"" of type '" "BlendStats *""'"); 
  }
  arg1 = reinterpret_cast< BlendStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlendStats_redundants_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->redundants = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlendStats_redundants_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendStats *arg1 = (BlendStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"BlendStats_redundants_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlendStats_redundants_get" "', argument " "1"" of type '" "BlendStats *""'"); 
  }
  arg1 = reinterpret_cast< BlendStats * >(argp1);
  result = (uint32_t) ((arg1)->redundants);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlendStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendStats *arg1 = (BlendStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_BlendStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlendStats" "', argument " "1"" of type '" "BlendStats *""'"); 
  }
  arg1 = reinterpret_cast< BlendStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_BlendStats) /* defines _wrap_delete_BlendStats_destructor_closure */

SWIGINTERN int _wrap_new_DepthStencilStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  DepthStencilStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (DepthStencilStats *)new DepthStencilStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DepthStencilStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DepthStencilStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DepthStencilStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DepthStencilStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DepthStencilStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DepthStencilStats" "', argument " "1"" of type '" "DepthStencilStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DepthStencilStats" "', argument " "1"" of type '" "DepthStencilStats const &""'"); 
  }
  arg1 = reinterpret_cast< DepthStencilStats * >(argp1);
  result = (DepthStencilStats *)new DepthStencilStats((DepthStencilStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DepthStencilStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DepthStencilStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DepthStencilStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DepthStencilStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_DepthStencilStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DepthStencilStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DepthStencilStats::DepthStencilStats()\n"
    "    DepthStencilStats::DepthStencilStats(DepthStencilStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_DepthStencilStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthStencilStats *arg1 = (DepthStencilStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthStencilStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthStencilStats_calls_set" "', argument " "1"" of type '" "DepthStencilStats *""'"); 
  }
  arg1 = reinterpret_cast< DepthStencilStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DepthStencilStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthStencilStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthStencilStats *arg1 = (DepthStencilStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DepthStencilStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthStencilStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthStencilStats_calls_get" "', argument " "1"" of type '" "DepthStencilStats *""'"); 
  }
  arg1 = reinterpret_cast< DepthStencilStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthStencilStats_sets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthStencilStats *arg1 = (DepthStencilStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthStencilStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthStencilStats_sets_set" "', argument " "1"" of type '" "DepthStencilStats *""'"); 
  }
  arg1 = reinterpret_cast< DepthStencilStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DepthStencilStats_sets_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sets = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthStencilStats_sets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthStencilStats *arg1 = (DepthStencilStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DepthStencilStats_sets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthStencilStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthStencilStats_sets_get" "', argument " "1"" of type '" "DepthStencilStats *""'"); 
  }
  arg1 = reinterpret_cast< DepthStencilStats * >(argp1);
  result = (uint32_t) ((arg1)->sets);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthStencilStats_nulls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthStencilStats *arg1 = (DepthStencilStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthStencilStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthStencilStats_nulls_set" "', argument " "1"" of type '" "DepthStencilStats *""'"); 
  }
  arg1 = reinterpret_cast< DepthStencilStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DepthStencilStats_nulls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->nulls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthStencilStats_nulls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthStencilStats *arg1 = (DepthStencilStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DepthStencilStats_nulls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthStencilStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthStencilStats_nulls_get" "', argument " "1"" of type '" "DepthStencilStats *""'"); 
  }
  arg1 = reinterpret_cast< DepthStencilStats * >(argp1);
  result = (uint32_t) ((arg1)->nulls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthStencilStats_redundants_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthStencilStats *arg1 = (DepthStencilStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthStencilStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthStencilStats_redundants_set" "', argument " "1"" of type '" "DepthStencilStats *""'"); 
  }
  arg1 = reinterpret_cast< DepthStencilStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DepthStencilStats_redundants_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->redundants = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DepthStencilStats_redundants_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthStencilStats *arg1 = (DepthStencilStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DepthStencilStats_redundants_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthStencilStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DepthStencilStats_redundants_get" "', argument " "1"" of type '" "DepthStencilStats *""'"); 
  }
  arg1 = reinterpret_cast< DepthStencilStats * >(argp1);
  result = (uint32_t) ((arg1)->redundants);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DepthStencilStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepthStencilStats *arg1 = (DepthStencilStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DepthStencilStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DepthStencilStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DepthStencilStats" "', argument " "1"" of type '" "DepthStencilStats *""'"); 
  }
  arg1 = reinterpret_cast< DepthStencilStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DepthStencilStats) /* defines _wrap_delete_DepthStencilStats_destructor_closure */

SWIGINTERN int _wrap_new_RasterizationStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RasterizationStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (RasterizationStats *)new RasterizationStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RasterizationStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_RasterizationStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  RasterizationStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RasterizationStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RasterizationStats" "', argument " "1"" of type '" "RasterizationStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RasterizationStats" "', argument " "1"" of type '" "RasterizationStats const &""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  result = (RasterizationStats *)new RasterizationStats((RasterizationStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RasterizationStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_RasterizationStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_RasterizationStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RasterizationStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_RasterizationStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RasterizationStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RasterizationStats::RasterizationStats()\n"
    "    RasterizationStats::RasterizationStats(RasterizationStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_RasterizationStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = (RasterizationStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterizationStats_calls_set" "', argument " "1"" of type '" "RasterizationStats *""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterizationStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterizationStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = (RasterizationStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"RasterizationStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterizationStats_calls_get" "', argument " "1"" of type '" "RasterizationStats *""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterizationStats_sets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = (RasterizationStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterizationStats_sets_set" "', argument " "1"" of type '" "RasterizationStats *""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterizationStats_sets_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sets = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterizationStats_sets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = (RasterizationStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"RasterizationStats_sets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterizationStats_sets_get" "', argument " "1"" of type '" "RasterizationStats *""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  result = (uint32_t) ((arg1)->sets);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterizationStats_nulls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = (RasterizationStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterizationStats_nulls_set" "', argument " "1"" of type '" "RasterizationStats *""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterizationStats_nulls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->nulls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterizationStats_nulls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = (RasterizationStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"RasterizationStats_nulls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterizationStats_nulls_get" "', argument " "1"" of type '" "RasterizationStats *""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  result = (uint32_t) ((arg1)->nulls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterizationStats_redundants_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = (RasterizationStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterizationStats_redundants_set" "', argument " "1"" of type '" "RasterizationStats *""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RasterizationStats_redundants_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->redundants = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterizationStats_redundants_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = (RasterizationStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"RasterizationStats_redundants_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterizationStats_redundants_get" "', argument " "1"" of type '" "RasterizationStats *""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  result = (uint32_t) ((arg1)->redundants);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterizationStats_viewports_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = (RasterizationStats *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterizationStats_viewports_set" "', argument " "1"" of type '" "RasterizationStats *""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'RasterizationStats_viewports_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'RasterizationStats_viewports_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->viewports = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterizationStats_viewports_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = (RasterizationStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"RasterizationStats_viewports_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterizationStats_viewports_get" "', argument " "1"" of type '" "RasterizationStats *""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->viewports);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterizationStats_rects_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = (RasterizationStats *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterizationStats_rects_set" "', argument " "1"" of type '" "RasterizationStats *""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'RasterizationStats_rects_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'RasterizationStats_rects_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->rects = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_RasterizationStats_rects_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = (RasterizationStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"RasterizationStats_rects_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RasterizationStats_rects_get" "', argument " "1"" of type '" "RasterizationStats *""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->rects);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RasterizationStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RasterizationStats *arg1 = (RasterizationStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_RasterizationStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_RasterizationStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RasterizationStats" "', argument " "1"" of type '" "RasterizationStats *""'"); 
  }
  arg1 = reinterpret_cast< RasterizationStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_RasterizationStats) /* defines _wrap_delete_RasterizationStats_destructor_closure */

SWIGINTERN int _wrap_new_OutputTargetStats__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  OutputTargetStats *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (OutputTargetStats *)new OutputTargetStats();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OutputTargetStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_OutputTargetStats__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OutputTargetStats *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  OutputTargetStats *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_OutputTargetStats,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OutputTargetStats" "', argument " "1"" of type '" "OutputTargetStats const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OutputTargetStats" "', argument " "1"" of type '" "OutputTargetStats const &""'"); 
  }
  arg1 = reinterpret_cast< OutputTargetStats * >(argp1);
  result = (OutputTargetStats *)new OutputTargetStats((OutputTargetStats const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OutputTargetStats, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_OutputTargetStats(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_OutputTargetStats",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_OutputTargetStats__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_OutputTargetStats__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OutputTargetStats'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OutputTargetStats::OutputTargetStats()\n"
    "    OutputTargetStats::OutputTargetStats(OutputTargetStats const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_OutputTargetStats_calls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OutputTargetStats *arg1 = (OutputTargetStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OutputTargetStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputTargetStats_calls_set" "', argument " "1"" of type '" "OutputTargetStats *""'"); 
  }
  arg1 = reinterpret_cast< OutputTargetStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OutputTargetStats_calls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->calls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OutputTargetStats_calls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OutputTargetStats *arg1 = (OutputTargetStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"OutputTargetStats_calls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OutputTargetStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputTargetStats_calls_get" "', argument " "1"" of type '" "OutputTargetStats *""'"); 
  }
  arg1 = reinterpret_cast< OutputTargetStats * >(argp1);
  result = (uint32_t) ((arg1)->calls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OutputTargetStats_sets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OutputTargetStats *arg1 = (OutputTargetStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OutputTargetStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputTargetStats_sets_set" "', argument " "1"" of type '" "OutputTargetStats *""'"); 
  }
  arg1 = reinterpret_cast< OutputTargetStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OutputTargetStats_sets_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sets = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OutputTargetStats_sets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OutputTargetStats *arg1 = (OutputTargetStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"OutputTargetStats_sets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OutputTargetStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputTargetStats_sets_get" "', argument " "1"" of type '" "OutputTargetStats *""'"); 
  }
  arg1 = reinterpret_cast< OutputTargetStats * >(argp1);
  result = (uint32_t) ((arg1)->sets);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OutputTargetStats_nulls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OutputTargetStats *arg1 = (OutputTargetStats *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OutputTargetStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputTargetStats_nulls_set" "', argument " "1"" of type '" "OutputTargetStats *""'"); 
  }
  arg1 = reinterpret_cast< OutputTargetStats * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OutputTargetStats_nulls_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->nulls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OutputTargetStats_nulls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OutputTargetStats *arg1 = (OutputTargetStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"OutputTargetStats_nulls_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OutputTargetStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputTargetStats_nulls_get" "', argument " "1"" of type '" "OutputTargetStats *""'"); 
  }
  arg1 = reinterpret_cast< OutputTargetStats * >(argp1);
  result = (uint32_t) ((arg1)->nulls);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OutputTargetStats_bindslots_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OutputTargetStats *arg1 = (OutputTargetStats *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OutputTargetStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputTargetStats_bindslots_set" "', argument " "1"" of type '" "OutputTargetStats *""'"); 
  }
  arg1 = reinterpret_cast< OutputTargetStats * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'OutputTargetStats_bindslots_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'OutputTargetStats_bindslots_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->bindslots = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_OutputTargetStats_bindslots_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OutputTargetStats *arg1 = (OutputTargetStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"OutputTargetStats_bindslots_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OutputTargetStats, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputTargetStats_bindslots_get" "', argument " "1"" of type '" "OutputTargetStats *""'"); 
  }
  arg1 = reinterpret_cast< OutputTargetStats * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->bindslots);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OutputTargetStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OutputTargetStats *arg1 = (OutputTargetStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_OutputTargetStats",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OutputTargetStats, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OutputTargetStats" "', argument " "1"" of type '" "OutputTargetStats *""'"); 
  }
  arg1 = reinterpret_cast< OutputTargetStats * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_OutputTargetStats) /* defines _wrap_delete_OutputTargetStats_destructor_closure */

SWIGINTERN int _wrap_new_FrameStatistics__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FrameStatistics *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (FrameStatistics *)new FrameStatistics();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FrameStatistics, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_FrameStatistics__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FrameStatistics *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FrameStatistics,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FrameStatistics" "', argument " "1"" of type '" "FrameStatistics const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FrameStatistics" "', argument " "1"" of type '" "FrameStatistics const &""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (FrameStatistics *)new FrameStatistics((FrameStatistics const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FrameStatistics, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_FrameStatistics(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_FrameStatistics",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_FrameStatistics__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_FrameStatistics__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FrameStatistics'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FrameStatistics::FrameStatistics()\n"
    "    FrameStatistics::FrameStatistics(FrameStatistics const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_recorded_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_recorded_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FrameStatistics_recorded_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->recorded = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_recorded_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_recorded_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_recorded_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (bool) ((arg1)->recorded);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_constants_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  rdcarray< ConstantBindStats > *arg2 = (rdcarray< ConstantBindStats > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_constants_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'FrameStatistics_constants_set' argument 2 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'FrameStatistics_constants_set' argument 2 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->constants = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_constants_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ConstantBindStats > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_constants_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_constants_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (rdcarray< ConstantBindStats > *)& ((arg1)->constants);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ConstantBindStats_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_samplers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  rdcarray< SamplerBindStats > *arg2 = (rdcarray< SamplerBindStats > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_samplers_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'FrameStatistics_samplers_set' argument 2 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'FrameStatistics_samplers_set' argument 2 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->samplers = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_samplers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< SamplerBindStats > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_samplers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_samplers_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (rdcarray< SamplerBindStats > *)& ((arg1)->samplers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_SamplerBindStats_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_resources_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  rdcarray< ResourceBindStats > *arg2 = (rdcarray< ResourceBindStats > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_resources_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'FrameStatistics_resources_set' argument 2 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'FrameStatistics_resources_set' argument 2 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->resources = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_resources_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ResourceBindStats > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_resources_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_resources_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (rdcarray< ResourceBindStats > *)& ((arg1)->resources);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ResourceBindStats_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_updates_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  ResourceUpdateStats *arg2 = (ResourceUpdateStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_updates_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceUpdateStats, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrameStatistics_updates_set" "', argument " "2"" of type '" "ResourceUpdateStats *""'"); 
  }
  arg2 = reinterpret_cast< ResourceUpdateStats * >(argp2);
  if (arg1) (arg1)->updates = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_updates_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceUpdateStats *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_updates_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_updates_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (ResourceUpdateStats *)& ((arg1)->updates);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceUpdateStats, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_draws_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  DrawcallStats *arg2 = (DrawcallStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_draws_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_DrawcallStats, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrameStatistics_draws_set" "', argument " "2"" of type '" "DrawcallStats *""'"); 
  }
  arg2 = reinterpret_cast< DrawcallStats * >(argp2);
  if (arg1) (arg1)->draws = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_draws_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DrawcallStats *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_draws_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_draws_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (DrawcallStats *)& ((arg1)->draws);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DrawcallStats, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_dispatches_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  DispatchStats *arg2 = (DispatchStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_dispatches_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_DispatchStats, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrameStatistics_dispatches_set" "', argument " "2"" of type '" "DispatchStats *""'"); 
  }
  arg2 = reinterpret_cast< DispatchStats * >(argp2);
  if (arg1) (arg1)->dispatches = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_dispatches_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DispatchStats *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_dispatches_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_dispatches_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (DispatchStats *)& ((arg1)->dispatches);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DispatchStats, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_indices_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  IndexBindStats *arg2 = (IndexBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_indices_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_IndexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrameStatistics_indices_set" "', argument " "2"" of type '" "IndexBindStats *""'"); 
  }
  arg2 = reinterpret_cast< IndexBindStats * >(argp2);
  if (arg1) (arg1)->indices = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_indices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  IndexBindStats *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_indices_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_indices_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (IndexBindStats *)& ((arg1)->indices);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IndexBindStats, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_vertices_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  VertexBindStats *arg2 = (VertexBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_vertices_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VertexBindStats, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrameStatistics_vertices_set" "', argument " "2"" of type '" "VertexBindStats *""'"); 
  }
  arg2 = reinterpret_cast< VertexBindStats * >(argp2);
  if (arg1) (arg1)->vertices = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_vertices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VertexBindStats *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_vertices_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_vertices_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (VertexBindStats *)& ((arg1)->vertices);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VertexBindStats, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_layouts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  LayoutBindStats *arg2 = (LayoutBindStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_layouts_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_LayoutBindStats, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrameStatistics_layouts_set" "', argument " "2"" of type '" "LayoutBindStats *""'"); 
  }
  arg2 = reinterpret_cast< LayoutBindStats * >(argp2);
  if (arg1) (arg1)->layouts = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_layouts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  LayoutBindStats *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_layouts_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_layouts_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (LayoutBindStats *)& ((arg1)->layouts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LayoutBindStats, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_shaders_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  rdcarray< ShaderChangeStats > *arg2 = (rdcarray< ShaderChangeStats > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_shaders_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'FrameStatistics_shaders_set' argument 2 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'FrameStatistics_shaders_set' argument 2 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->shaders = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_shaders_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderChangeStats > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_shaders_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_shaders_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (rdcarray< ShaderChangeStats > *)& ((arg1)->shaders);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderChangeStats_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_blends_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  BlendStats *arg2 = (BlendStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_blends_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_BlendStats, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrameStatistics_blends_set" "', argument " "2"" of type '" "BlendStats *""'"); 
  }
  arg2 = reinterpret_cast< BlendStats * >(argp2);
  if (arg1) (arg1)->blends = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_blends_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BlendStats *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_blends_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_blends_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (BlendStats *)& ((arg1)->blends);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BlendStats, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_depths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  DepthStencilStats *arg2 = (DepthStencilStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_depths_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_DepthStencilStats, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrameStatistics_depths_set" "', argument " "2"" of type '" "DepthStencilStats *""'"); 
  }
  arg2 = reinterpret_cast< DepthStencilStats * >(argp2);
  if (arg1) (arg1)->depths = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_depths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DepthStencilStats *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_depths_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_depths_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (DepthStencilStats *)& ((arg1)->depths);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DepthStencilStats, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_rasters_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  RasterizationStats *arg2 = (RasterizationStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_rasters_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrameStatistics_rasters_set" "', argument " "2"" of type '" "RasterizationStats *""'"); 
  }
  arg2 = reinterpret_cast< RasterizationStats * >(argp2);
  if (arg1) (arg1)->rasters = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_rasters_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  RasterizationStats *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_rasters_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_rasters_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (RasterizationStats *)& ((arg1)->rasters);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RasterizationStats, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_outputs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  OutputTargetStats *arg2 = (OutputTargetStats *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_outputs_set" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_OutputTargetStats, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrameStatistics_outputs_set" "', argument " "2"" of type '" "OutputTargetStats *""'"); 
  }
  arg2 = reinterpret_cast< OutputTargetStats * >(argp2);
  if (arg1) (arg1)->outputs = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameStatistics_outputs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  OutputTargetStats *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameStatistics_outputs_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameStatistics_outputs_get" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  result = (OutputTargetStats *)& ((arg1)->outputs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OutputTargetStats, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FrameStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameStatistics *arg1 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_FrameStatistics",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameStatistics, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FrameStatistics" "', argument " "1"" of type '" "FrameStatistics *""'"); 
  }
  arg1 = reinterpret_cast< FrameStatistics * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_FrameStatistics) /* defines _wrap_delete_FrameStatistics_destructor_closure */

SWIGINTERN int _wrap_new_FrameDescription__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FrameDescription *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (FrameDescription *)new FrameDescription();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FrameDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_FrameDescription__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FrameDescription *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FrameDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FrameDescription" "', argument " "1"" of type '" "FrameDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FrameDescription" "', argument " "1"" of type '" "FrameDescription const &""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  result = (FrameDescription *)new FrameDescription((FrameDescription const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FrameDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_FrameDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_FrameDescription",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_FrameDescription__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_FrameDescription__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FrameDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FrameDescription::FrameDescription()\n"
    "    FrameDescription::FrameDescription(FrameDescription const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_FrameDescription_frameNumber_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_frameNumber_set" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FrameDescription_frameNumber_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->frameNumber = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_frameNumber_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameDescription_frameNumber_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_frameNumber_get" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  result = (uint32_t) ((arg1)->frameNumber);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_fileOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_fileOffset_set" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FrameDescription_fileOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->fileOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_fileOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameDescription_fileOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_fileOffset_get" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  result = (uint64_t) ((arg1)->fileOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_uncompressedFileSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_uncompressedFileSize_set" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FrameDescription_uncompressedFileSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->uncompressedFileSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_uncompressedFileSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameDescription_uncompressedFileSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_uncompressedFileSize_get" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  result = (uint64_t) ((arg1)->uncompressedFileSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_compressedFileSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_compressedFileSize_set" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FrameDescription_compressedFileSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->compressedFileSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_compressedFileSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameDescription_compressedFileSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_compressedFileSize_get" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  result = (uint64_t) ((arg1)->compressedFileSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_persistentSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_persistentSize_set" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FrameDescription_persistentSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->persistentSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_persistentSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameDescription_persistentSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_persistentSize_get" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  result = (uint64_t) ((arg1)->persistentSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_initDataSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_initDataSize_set" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FrameDescription_initDataSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->initDataSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_initDataSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameDescription_initDataSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_initDataSize_get" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  result = (uint64_t) ((arg1)->initDataSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_captureTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_captureTime_set" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FrameDescription_captureTime_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->captureTime = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_captureTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameDescription_captureTime_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_captureTime_get" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  result = (uint64_t) ((arg1)->captureTime);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_stats_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  FrameStatistics *arg2 = (FrameStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_stats_set" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrameDescription_stats_set" "', argument " "2"" of type '" "FrameStatistics *""'"); 
  }
  arg2 = reinterpret_cast< FrameStatistics * >(argp2);
  if (arg1) (arg1)->stats = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_stats_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FrameStatistics *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameDescription_stats_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_stats_get" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  result = (FrameStatistics *)& ((arg1)->stats);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FrameStatistics, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_debugMessages_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  rdcarray< DebugMessage > *arg2 = (rdcarray< DebugMessage > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_debugMessages_set" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'FrameDescription_debugMessages_set' argument 2 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'FrameDescription_debugMessages_set' argument 2 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->debugMessages = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_debugMessages_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< DebugMessage > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameDescription_debugMessages_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_debugMessages_get" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  result = (rdcarray< DebugMessage > *)& ((arg1)->debugMessages);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_DebugMessage_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_containsAnnotations_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_containsAnnotations_set" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FrameDescription_containsAnnotations_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->containsAnnotations = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FrameDescription_containsAnnotations_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"FrameDescription_containsAnnotations_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDescription_containsAnnotations_get" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  result = (bool) ((arg1)->containsAnnotations);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FrameDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FrameDescription *arg1 = (FrameDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_FrameDescription",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FrameDescription, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FrameDescription" "', argument " "1"" of type '" "FrameDescription *""'"); 
  }
  arg1 = reinterpret_cast< FrameDescription * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_FrameDescription) /* defines _wrap_delete_FrameDescription_destructor_closure */

SWIGINTERN int _wrap_new_EventUsage__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EventUsage *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (EventUsage *)new EventUsage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventUsage, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_EventUsage__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  EventUsage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EventUsage *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_EventUsage,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventUsage" "', argument " "1"" of type '" "EventUsage const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EventUsage" "', argument " "1"" of type '" "EventUsage const &""'"); 
  }
  arg1 = reinterpret_cast< EventUsage * >(argp1);
  result = (EventUsage *)new EventUsage((EventUsage const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventUsage, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_EventUsage__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  ResourceUsage arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  EventUsage *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EventUsage" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventUsage" "', argument " "2"" of type '" "ResourceUsage""'");
  } 
  arg2 = static_cast< ResourceUsage >(val2);
  result = (EventUsage *)new EventUsage(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventUsage, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_EventUsage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_EventUsage",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EventUsage__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_EventUsage__SWIG_1(self, argc, argv);
  }
  if (argc == 2) {
    return _wrap_new_EventUsage__SWIG_2(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EventUsage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EventUsage::EventUsage()\n"
    "    EventUsage::EventUsage(EventUsage const &)\n"
    "    EventUsage::EventUsage(uint32_t,ResourceUsage)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_EventUsage___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EventUsage *arg1 = (EventUsage *) 0 ;
  EventUsage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EventUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventUsage___lt__" "', argument " "1"" of type '" "EventUsage const *""'"); 
  }
  arg1 = reinterpret_cast< EventUsage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_EventUsage,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventUsage___lt__" "', argument " "2"" of type '" "EventUsage const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EventUsage___lt__" "', argument " "2"" of type '" "EventUsage const &""'"); 
  }
  arg2 = reinterpret_cast< EventUsage * >(argp2);
  result = (bool)((EventUsage const *)arg1)->operator <((EventUsage const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventUsage_eventId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EventUsage *arg1 = (EventUsage *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EventUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventUsage_eventId_set" "', argument " "1"" of type '" "EventUsage *""'"); 
  }
  arg1 = reinterpret_cast< EventUsage * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventUsage_eventId_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->eventId = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventUsage_eventId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EventUsage *arg1 = (EventUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"EventUsage_eventId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EventUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventUsage_eventId_get" "', argument " "1"" of type '" "EventUsage *""'"); 
  }
  arg1 = reinterpret_cast< EventUsage * >(argp1);
  result = (uint32_t) ((arg1)->eventId);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventUsage_usage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EventUsage *arg1 = (EventUsage *) 0 ;
  ResourceUsage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EventUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventUsage_usage_set" "', argument " "1"" of type '" "EventUsage *""'"); 
  }
  arg1 = reinterpret_cast< EventUsage * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventUsage_usage_set" "', argument " "2"" of type '" "ResourceUsage""'");
  } 
  arg2 = static_cast< ResourceUsage >(val2);
  if (arg1) (arg1)->usage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventUsage_usage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EventUsage *arg1 = (EventUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceUsage result;
  
  if (!SWIG_Python_UnpackTuple(args,"EventUsage_usage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EventUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventUsage_usage_get" "', argument " "1"" of type '" "EventUsage *""'"); 
  }
  arg1 = reinterpret_cast< EventUsage * >(argp1);
  result = (ResourceUsage) ((arg1)->usage);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ResourceUsage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventUsage___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EventUsage *arg1 = (EventUsage *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EventUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventUsage___eq__" "', argument " "1"" of type '" "EventUsage *""'"); 
  }
  arg1 = reinterpret_cast< EventUsage * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)EventUsage___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventUsage___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EventUsage *arg1 = (EventUsage *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EventUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventUsage___ne__" "', argument " "1"" of type '" "EventUsage *""'"); 
  }
  arg1 = reinterpret_cast< EventUsage * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)EventUsage___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EventUsage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EventUsage *arg1 = (EventUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_EventUsage",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EventUsage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventUsage" "', argument " "1"" of type '" "EventUsage *""'"); 
  }
  arg1 = reinterpret_cast< EventUsage * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_EventUsage) /* defines _wrap_delete_EventUsage_destructor_closure */

SWIGINTERN int _wrap_new_Subresource__SWIG_0(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Subresource *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Subresource" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Subresource" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Subresource" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  result = (Subresource *)new Subresource(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Subresource, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Subresource__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  uint32_t arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Subresource *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Subresource" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Subresource" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  result = (Subresource *)new Subresource(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Subresource, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Subresource__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  Subresource *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Subresource" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  result = (Subresource *)new Subresource(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Subresource, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Subresource__SWIG_3(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Subresource *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (Subresource *)new Subresource();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Subresource, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Subresource__SWIG_4(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Subresource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Subresource *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Subresource,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Subresource" "', argument " "1"" of type '" "Subresource const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Subresource" "', argument " "1"" of type '" "Subresource const &""'"); 
  }
  arg1 = reinterpret_cast< Subresource * >(argp1);
  result = (Subresource *)new Subresource((Subresource const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Subresource, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Subresource(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Subresource",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Subresource__SWIG_3(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Subresource, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_Subresource__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    return _wrap_new_Subresource__SWIG_2(self, argc, argv);
  }
  if (argc == 2) {
    return _wrap_new_Subresource__SWIG_1(self, argc, argv);
  }
  if (argc == 3) {
    return _wrap_new_Subresource__SWIG_0(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Subresource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Subresource::Subresource(uint32_t,uint32_t,uint32_t)\n"
    "    Subresource::Subresource(uint32_t,uint32_t)\n"
    "    Subresource::Subresource(uint32_t)\n"
    "    Subresource::Subresource()\n"
    "    Subresource::Subresource(Subresource const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_Subresource___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Subresource *arg1 = (Subresource *) 0 ;
  Subresource *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Subresource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Subresource___eq__" "', argument " "1"" of type '" "Subresource const *""'"); 
  }
  arg1 = reinterpret_cast< Subresource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_Subresource,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Subresource___eq__" "', argument " "2"" of type '" "Subresource const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Subresource___eq__" "', argument " "2"" of type '" "Subresource const &""'"); 
  }
  arg2 = reinterpret_cast< Subresource * >(argp2);
  result = (bool)((Subresource const *)arg1)->operator ==((Subresource const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Subresource___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Subresource *arg1 = (Subresource *) 0 ;
  Subresource *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Subresource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Subresource___ne__" "', argument " "1"" of type '" "Subresource const *""'"); 
  }
  arg1 = reinterpret_cast< Subresource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_Subresource,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Subresource___ne__" "', argument " "2"" of type '" "Subresource const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Subresource___ne__" "', argument " "2"" of type '" "Subresource const &""'"); 
  }
  arg2 = reinterpret_cast< Subresource * >(argp2);
  result = (bool)((Subresource const *)arg1)->operator !=((Subresource const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Subresource___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Subresource *arg1 = (Subresource *) 0 ;
  Subresource *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Subresource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Subresource___lt__" "', argument " "1"" of type '" "Subresource const *""'"); 
  }
  arg1 = reinterpret_cast< Subresource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_Subresource,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Subresource___lt__" "', argument " "2"" of type '" "Subresource const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Subresource___lt__" "', argument " "2"" of type '" "Subresource const &""'"); 
  }
  arg2 = reinterpret_cast< Subresource * >(argp2);
  result = (bool)((Subresource const *)arg1)->operator <((Subresource const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Subresource_mip_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Subresource *arg1 = (Subresource *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Subresource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Subresource_mip_set" "', argument " "1"" of type '" "Subresource *""'"); 
  }
  arg1 = reinterpret_cast< Subresource * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Subresource_mip_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->mip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Subresource_mip_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Subresource *arg1 = (Subresource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Subresource_mip_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Subresource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Subresource_mip_get" "', argument " "1"" of type '" "Subresource *""'"); 
  }
  arg1 = reinterpret_cast< Subresource * >(argp1);
  result = (uint32_t) ((arg1)->mip);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Subresource_slice_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Subresource *arg1 = (Subresource *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Subresource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Subresource_slice_set" "', argument " "1"" of type '" "Subresource *""'"); 
  }
  arg1 = reinterpret_cast< Subresource * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Subresource_slice_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->slice = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Subresource_slice_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Subresource *arg1 = (Subresource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Subresource_slice_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Subresource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Subresource_slice_get" "', argument " "1"" of type '" "Subresource *""'"); 
  }
  arg1 = reinterpret_cast< Subresource * >(argp1);
  result = (uint32_t) ((arg1)->slice);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Subresource_sample_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Subresource *arg1 = (Subresource *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Subresource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Subresource_sample_set" "', argument " "1"" of type '" "Subresource *""'"); 
  }
  arg1 = reinterpret_cast< Subresource * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Subresource_sample_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sample = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Subresource_sample_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Subresource *arg1 = (Subresource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Subresource_sample_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Subresource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Subresource_sample_get" "', argument " "1"" of type '" "Subresource *""'"); 
  }
  arg1 = reinterpret_cast< Subresource * >(argp1);
  result = (uint32_t) ((arg1)->sample);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Subresource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Subresource *arg1 = (Subresource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_Subresource",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Subresource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Subresource" "', argument " "1"" of type '" "Subresource *""'"); 
  }
  arg1 = reinterpret_cast< Subresource * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_Subresource) /* defines _wrap_delete_Subresource_destructor_closure */

SWIGINTERN int _wrap_new_ActionDescription__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ActionDescription *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ActionDescription *)new ActionDescription();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ActionDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ActionDescription__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ActionDescription *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ActionDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ActionDescription" "', argument " "1"" of type '" "ActionDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ActionDescription" "', argument " "1"" of type '" "ActionDescription const &""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (ActionDescription *)new ActionDescription((ActionDescription const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ActionDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ActionDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ActionDescription",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ActionDescription__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ActionDescription__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ActionDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ActionDescription::ActionDescription()\n"
    "    ActionDescription::ActionDescription(ActionDescription const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ActionDescription_IsFakeMarker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_IsFakeMarker",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_IsFakeMarker" "', argument " "1"" of type '" "ActionDescription const *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (bool)((ActionDescription const *)arg1)->IsFakeMarker();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_GetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  SDFile *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  rdcstr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_GetName" "', argument " "1"" of type '" "ActionDescription const *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_SDFile,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ActionDescription_GetName" "', argument " "2"" of type '" "SDFile const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ActionDescription_GetName" "', argument " "2"" of type '" "SDFile const &""'"); 
  }
  arg2 = reinterpret_cast< SDFile * >(argp2);
  result = ((ActionDescription const *)arg1)->GetName((SDFile const &)*arg2);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  ActionDescription *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription___lt__" "', argument " "1"" of type '" "ActionDescription const *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ActionDescription,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ActionDescription___lt__" "', argument " "2"" of type '" "ActionDescription const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ActionDescription___lt__" "', argument " "2"" of type '" "ActionDescription const &""'"); 
  }
  arg2 = reinterpret_cast< ActionDescription * >(argp2);
  result = (bool)((ActionDescription const *)arg1)->operator <((ActionDescription const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_eventId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_eventId_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActionDescription_eventId_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->eventId = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_eventId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_eventId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_eventId_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (uint32_t) ((arg1)->eventId);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_actionId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_actionId_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActionDescription_actionId_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->actionId = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_actionId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_actionId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_actionId_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (uint32_t) ((arg1)->actionId);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_customName_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_customName_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ActionDescription_customName_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->customName = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_customName_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_customName_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_customName_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result =  ((arg1)->customName);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  ActionFlags arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_flags_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActionDescription_flags_set" "', argument " "2"" of type '" "ActionFlags""'");
  } 
  arg2 = static_cast< ActionFlags >(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ActionFlags result;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_flags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_flags_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (ActionFlags) ((arg1)->flags);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ActionFlags->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_markerColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  FloatVector *arg2 = (FloatVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_markerColor_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_FloatVector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ActionDescription_markerColor_set" "', argument " "2"" of type '" "FloatVector *""'"); 
  }
  arg2 = reinterpret_cast< FloatVector * >(argp2);
  if (arg1) (arg1)->markerColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_markerColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatVector *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_markerColor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_markerColor_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (FloatVector *)& ((arg1)->markerColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloatVector, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_numIndices_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_numIndices_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActionDescription_numIndices_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->numIndices = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_numIndices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_numIndices_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_numIndices_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (uint32_t) ((arg1)->numIndices);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_numInstances_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_numInstances_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActionDescription_numInstances_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->numInstances = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_numInstances_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_numInstances_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_numInstances_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (uint32_t) ((arg1)->numInstances);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_baseVertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_baseVertex_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActionDescription_baseVertex_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->baseVertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_baseVertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_baseVertex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_baseVertex_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (int32_t) ((arg1)->baseVertex);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_indexOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_indexOffset_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActionDescription_indexOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->indexOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_indexOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_indexOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_indexOffset_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (uint32_t) ((arg1)->indexOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_vertexOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_vertexOffset_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActionDescription_vertexOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->vertexOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_vertexOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_vertexOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_vertexOffset_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (uint32_t) ((arg1)->vertexOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_instanceOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_instanceOffset_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActionDescription_instanceOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->instanceOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_instanceOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_instanceOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_instanceOffset_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (uint32_t) ((arg1)->instanceOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_drawIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_drawIndex_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActionDescription_drawIndex_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->drawIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_drawIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_drawIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_drawIndex_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (uint32_t) ((arg1)->drawIndex);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_dispatchDimension_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  rdcfixedarray< uint32_t,3 > *arg2 = (rdcfixedarray< uint32_t,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_dispatchDimension_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ActionDescription_dispatchDimension_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ActionDescription_dispatchDimension_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->dispatchDimension = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_dispatchDimension_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint32_t,3 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_dispatchDimension_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_dispatchDimension_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (rdcfixedarray< uint32_t,3 > *)& ((arg1)->dispatchDimension);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_dispatchThreadsDimension_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  rdcfixedarray< uint32_t,3 > *arg2 = (rdcfixedarray< uint32_t,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_dispatchThreadsDimension_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ActionDescription_dispatchThreadsDimension_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ActionDescription_dispatchThreadsDimension_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->dispatchThreadsDimension = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_dispatchThreadsDimension_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint32_t,3 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_dispatchThreadsDimension_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_dispatchThreadsDimension_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (rdcfixedarray< uint32_t,3 > *)& ((arg1)->dispatchThreadsDimension);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_dispatchBase_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  rdcfixedarray< uint32_t,3 > *arg2 = (rdcfixedarray< uint32_t,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_dispatchBase_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ActionDescription_dispatchBase_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ActionDescription_dispatchBase_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->dispatchBase = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_dispatchBase_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint32_t,3 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_dispatchBase_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_dispatchBase_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (rdcfixedarray< uint32_t,3 > *)& ((arg1)->dispatchBase);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_copySource_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_copySource_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ActionDescription_copySource_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->copySource = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_copySource_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_copySource_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_copySource_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (ResourceId *)& ((arg1)->copySource);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_copySourceSubresource_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  Subresource *arg2 = (Subresource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_copySourceSubresource_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_Subresource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ActionDescription_copySourceSubresource_set" "', argument " "2"" of type '" "Subresource *""'"); 
  }
  arg2 = reinterpret_cast< Subresource * >(argp2);
  if (arg1) (arg1)->copySourceSubresource = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_copySourceSubresource_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Subresource *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_copySourceSubresource_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_copySourceSubresource_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (Subresource *)& ((arg1)->copySourceSubresource);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Subresource, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_copyDestination_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_copyDestination_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ActionDescription_copyDestination_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->copyDestination = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_copyDestination_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_copyDestination_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_copyDestination_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (ResourceId *)& ((arg1)->copyDestination);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_copyDestinationSubresource_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  Subresource *arg2 = (Subresource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_copyDestinationSubresource_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_Subresource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ActionDescription_copyDestinationSubresource_set" "', argument " "2"" of type '" "Subresource *""'"); 
  }
  arg2 = reinterpret_cast< Subresource * >(argp2);
  if (arg1) (arg1)->copyDestinationSubresource = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_copyDestinationSubresource_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Subresource *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_copyDestinationSubresource_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_copyDestinationSubresource_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (Subresource *)& ((arg1)->copyDestinationSubresource);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Subresource, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  ActionDescription *arg2 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_parent_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ActionDescription, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ActionDescription_parent_set" "', argument " "2"" of type '" "ActionDescription const *""'"); 
  }
  arg2 = reinterpret_cast< ActionDescription * >(argp2);
  if (arg1) (arg1)->parent = (ActionDescription const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ActionDescription *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_parent_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_parent_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (ActionDescription *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    // for ActionDescription pointers don't apply parent tracking, since these are preserved
    // in other ways and the linked-list nature of walking them can produce absurdly long
    // parent chains
    if (SwigPyObject_Check(resultobj))
    {
      SwigPyObject *sobj = (SwigPyObject *)resultobj;
      if(sobj->parent)
      {
        sobj->parent = NULL;
        Py_DECREF(self);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_previous_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  ActionDescription *arg2 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_previous_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ActionDescription, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ActionDescription_previous_set" "', argument " "2"" of type '" "ActionDescription const *""'"); 
  }
  arg2 = reinterpret_cast< ActionDescription * >(argp2);
  if (arg1) (arg1)->previous = (ActionDescription const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_previous_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ActionDescription *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_previous_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_previous_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (ActionDescription *) ((arg1)->previous);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    // for ActionDescription pointers don't apply parent tracking, since these are preserved
    // in other ways and the linked-list nature of walking them can produce absurdly long
    // parent chains
    if (SwigPyObject_Check(resultobj))
    {
      SwigPyObject *sobj = (SwigPyObject *)resultobj;
      if(sobj->parent)
      {
        sobj->parent = NULL;
        Py_DECREF(self);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_next_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  ActionDescription *arg2 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_next_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ActionDescription, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ActionDescription_next_set" "', argument " "2"" of type '" "ActionDescription const *""'"); 
  }
  arg2 = reinterpret_cast< ActionDescription * >(argp2);
  if (arg1) (arg1)->next = (ActionDescription const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_next_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ActionDescription *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_next_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_next_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (ActionDescription *) ((arg1)->next);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    // for ActionDescription pointers don't apply parent tracking, since these are preserved
    // in other ways and the linked-list nature of walking them can produce absurdly long
    // parent chains
    if (SwigPyObject_Check(resultobj))
    {
      SwigPyObject *sobj = (SwigPyObject *)resultobj;
      if(sobj->parent)
      {
        sobj->parent = NULL;
        Py_DECREF(self);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_outputs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  rdcfixedarray< ResourceId,8 > *arg2 = (rdcfixedarray< ResourceId,8 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_outputs_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ActionDescription_outputs_set' argument 2 of type 'rdcfixedarray< ResourceId,8 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ActionDescription_outputs_set' argument 2 of type 'rdcfixedarray< ResourceId,8 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->outputs = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_outputs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< ResourceId,8 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_outputs_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_outputs_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (rdcfixedarray< ResourceId,8 > *)& ((arg1)->outputs);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_depthOut_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_depthOut_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ActionDescription_depthOut_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->depthOut = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_depthOut_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_depthOut_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_depthOut_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (ResourceId *)& ((arg1)->depthOut);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_events_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  rdcarray< APIEvent > *arg2 = (rdcarray< APIEvent > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_events_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ActionDescription_events_set' argument 2 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ActionDescription_events_set' argument 2 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->events = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_events_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< APIEvent > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_events_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_events_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (rdcarray< APIEvent > *)& ((arg1)->events);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_APIEvent_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_children_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  rdcarray< ActionDescription > *arg2 = (rdcarray< ActionDescription > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_children_set" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ActionDescription_children_set' argument 2 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ActionDescription_children_set' argument 2 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->children = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription_children_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ActionDescription > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ActionDescription_children_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription_children_get" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  result = (rdcarray< ActionDescription > *)& ((arg1)->children);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ActionDescription_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription___eq__" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ActionDescription___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ActionDescription___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionDescription___ne__" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ActionDescription___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ActionDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionDescription *arg1 = (ActionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ActionDescription",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionDescription, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ActionDescription" "', argument " "1"" of type '" "ActionDescription *""'"); 
  }
  arg1 = reinterpret_cast< ActionDescription * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ActionDescription) /* defines _wrap_delete_ActionDescription_destructor_closure */

SWIGINTERN int _wrap_new_APIProperties__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  APIProperties *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (APIProperties *)new APIProperties();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_APIProperties, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_APIProperties__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  APIProperties *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_APIProperties,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_APIProperties" "', argument " "1"" of type '" "APIProperties const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_APIProperties" "', argument " "1"" of type '" "APIProperties const &""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  result = (APIProperties *)new APIProperties((APIProperties const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_APIProperties, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_APIProperties(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_APIProperties",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_APIProperties__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_APIProperties__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_APIProperties'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    APIProperties::APIProperties()\n"
    "    APIProperties::APIProperties(APIProperties const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_APIProperties_pipelineType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  GraphicsAPI arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_pipelineType_set" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "APIProperties_pipelineType_set" "', argument " "2"" of type '" "GraphicsAPI""'");
  } 
  arg2 = static_cast< GraphicsAPI >(val2);
  if (arg1) (arg1)->pipelineType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_pipelineType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GraphicsAPI result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIProperties_pipelineType_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_pipelineType_get" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  result = (GraphicsAPI) ((arg1)->pipelineType);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_GraphicsAPI->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_localRenderer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  GraphicsAPI arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_localRenderer_set" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "APIProperties_localRenderer_set" "', argument " "2"" of type '" "GraphicsAPI""'");
  } 
  arg2 = static_cast< GraphicsAPI >(val2);
  if (arg1) (arg1)->localRenderer = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_localRenderer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GraphicsAPI result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIProperties_localRenderer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_localRenderer_get" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  result = (GraphicsAPI) ((arg1)->localRenderer);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_GraphicsAPI->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_vendor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  GPUVendor arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_vendor_set" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "APIProperties_vendor_set" "', argument " "2"" of type '" "GPUVendor""'");
  } 
  arg2 = static_cast< GPUVendor >(val2);
  if (arg1) (arg1)->vendor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_vendor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GPUVendor result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIProperties_vendor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_vendor_get" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  result = (GPUVendor) ((arg1)->vendor);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_GPUVendor->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_remoteReplay_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_remoteReplay_set" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "APIProperties_remoteReplay_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->remoteReplay = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_remoteReplay_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIProperties_remoteReplay_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_remoteReplay_get" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  result = (bool) ((arg1)->remoteReplay);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_degraded_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_degraded_set" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "APIProperties_degraded_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->degraded = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_degraded_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIProperties_degraded_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_degraded_get" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  result = (bool) ((arg1)->degraded);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_shaderDebugging_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_shaderDebugging_set" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "APIProperties_shaderDebugging_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->shaderDebugging = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_shaderDebugging_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIProperties_shaderDebugging_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_shaderDebugging_get" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  result = (bool) ((arg1)->shaderDebugging);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_pixelHistory_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_pixelHistory_set" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "APIProperties_pixelHistory_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->pixelHistory = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_pixelHistory_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIProperties_pixelHistory_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_pixelHistory_get" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  result = (bool) ((arg1)->pixelHistory);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_rgpCapture_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_rgpCapture_set" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "APIProperties_rgpCapture_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->rgpCapture = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_APIProperties_rgpCapture_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"APIProperties_rgpCapture_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "APIProperties_rgpCapture_get" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  result = (bool) ((arg1)->rgpCapture);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_APIProperties(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  APIProperties *arg1 = (APIProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_APIProperties",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_APIProperties, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_APIProperties" "', argument " "1"" of type '" "APIProperties *""'"); 
  }
  arg1 = reinterpret_cast< APIProperties * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_APIProperties) /* defines _wrap_delete_APIProperties_destructor_closure */

SWIGINTERN int _wrap_new_DriverInformation__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  DriverInformation *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (DriverInformation *)new DriverInformation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DriverInformation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DriverInformation__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DriverInformation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DriverInformation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DriverInformation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DriverInformation" "', argument " "1"" of type '" "DriverInformation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DriverInformation" "', argument " "1"" of type '" "DriverInformation const &""'"); 
  }
  arg1 = reinterpret_cast< DriverInformation * >(argp1);
  result = (DriverInformation *)new DriverInformation((DriverInformation const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DriverInformation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DriverInformation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DriverInformation",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DriverInformation__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_DriverInformation__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DriverInformation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DriverInformation::DriverInformation()\n"
    "    DriverInformation::DriverInformation(DriverInformation const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_DriverInformation_vendor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DriverInformation *arg1 = (DriverInformation *) 0 ;
  GPUVendor arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DriverInformation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DriverInformation_vendor_set" "', argument " "1"" of type '" "DriverInformation *""'"); 
  }
  arg1 = reinterpret_cast< DriverInformation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DriverInformation_vendor_set" "', argument " "2"" of type '" "GPUVendor""'");
  } 
  arg2 = static_cast< GPUVendor >(val2);
  if (arg1) (arg1)->vendor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DriverInformation_vendor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DriverInformation *arg1 = (DriverInformation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GPUVendor result;
  
  if (!SWIG_Python_UnpackTuple(args,"DriverInformation_vendor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DriverInformation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DriverInformation_vendor_get" "', argument " "1"" of type '" "DriverInformation *""'"); 
  }
  arg1 = reinterpret_cast< DriverInformation * >(argp1);
  result = (GPUVendor) ((arg1)->vendor);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_GPUVendor->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DriverInformation_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DriverInformation *arg1 = (DriverInformation *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[128] ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DriverInformation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DriverInformation_version_set" "', argument " "1"" of type '" "DriverInformation *""'"); 
  }
  arg1 = reinterpret_cast< DriverInformation * >(argp1);
  res2 = SWIG_AsCharArray(swig_obj[0], temp2, 128);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DriverInformation_version_set" "', argument " "2"" of type '" "char [128]""'");
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->version,arg2,128*sizeof(char));
  else memset(arg1->version,0,128*sizeof(char));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DriverInformation_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DriverInformation *arg1 = (DriverInformation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"DriverInformation_version_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DriverInformation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DriverInformation_version_get" "', argument " "1"" of type '" "DriverInformation *""'"); 
  }
  arg1 = reinterpret_cast< DriverInformation * >(argp1);
  result = (char *)(char *) ((arg1)->version);
  {
    size_t size = SWIG_strnlen(result, 128);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DriverInformation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DriverInformation *arg1 = (DriverInformation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DriverInformation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DriverInformation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DriverInformation" "', argument " "1"" of type '" "DriverInformation *""'"); 
  }
  arg1 = reinterpret_cast< DriverInformation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DriverInformation) /* defines _wrap_delete_DriverInformation_destructor_closure */

SWIGINTERN int _wrap_new_Uuid__SWIG_0(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  Uuid *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Uuid" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Uuid" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Uuid" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Uuid" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  result = (Uuid *)new Uuid(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Uuid, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Uuid__SWIG_1(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Uuid *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (Uuid *)new Uuid();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Uuid, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Uuid__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Uuid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Uuid *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Uuid,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Uuid" "', argument " "1"" of type '" "Uuid const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Uuid" "', argument " "1"" of type '" "Uuid const &""'"); 
  }
  arg1 = reinterpret_cast< Uuid * >(argp1);
  result = (Uuid *)new Uuid((Uuid const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Uuid, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Uuid(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Uuid",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Uuid__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_Uuid__SWIG_2(self, argc, argv);
  }
  if (argc == 4) {
    return _wrap_new_Uuid__SWIG_0(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Uuid'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Uuid::Uuid(uint32_t,uint32_t,uint32_t,uint32_t)\n"
    "    Uuid::Uuid()\n"
    "    Uuid::Uuid(Uuid const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_Uuid___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Uuid *arg1 = (Uuid *) 0 ;
  Uuid *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Uuid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Uuid___lt__" "', argument " "1"" of type '" "Uuid const *""'"); 
  }
  arg1 = reinterpret_cast< Uuid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_Uuid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Uuid___lt__" "', argument " "2"" of type '" "Uuid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Uuid___lt__" "', argument " "2"" of type '" "Uuid const &""'"); 
  }
  arg2 = reinterpret_cast< Uuid * >(argp2);
  result = (bool)((Uuid const *)arg1)->operator <((Uuid const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Uuid___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Uuid *arg1 = (Uuid *) 0 ;
  Uuid *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Uuid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Uuid___eq__" "', argument " "1"" of type '" "Uuid const *""'"); 
  }
  arg1 = reinterpret_cast< Uuid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_Uuid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Uuid___eq__" "', argument " "2"" of type '" "Uuid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Uuid___eq__" "', argument " "2"" of type '" "Uuid const &""'"); 
  }
  arg2 = reinterpret_cast< Uuid * >(argp2);
  result = (bool)((Uuid const *)arg1)->operator ==((Uuid const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Uuid_words_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Uuid *arg1 = (Uuid *) 0 ;
  rdcfixedarray< uint32_t,4 > *arg2 = (rdcfixedarray< uint32_t,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Uuid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Uuid_words_set" "', argument " "1"" of type '" "Uuid *""'"); 
  }
  arg1 = reinterpret_cast< Uuid * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'Uuid_words_set' argument 2 of type 'rdcfixedarray< uint32_t,4 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'Uuid_words_set' argument 2 of type 'rdcfixedarray< uint32_t,4 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->words = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Uuid_words_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Uuid *arg1 = (Uuid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint32_t,4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"Uuid_words_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Uuid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Uuid_words_get" "', argument " "1"" of type '" "Uuid *""'"); 
  }
  arg1 = reinterpret_cast< Uuid * >(argp1);
  result = (rdcfixedarray< uint32_t,4 > *)& ((arg1)->words);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Uuid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Uuid *arg1 = (Uuid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_Uuid",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Uuid, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Uuid" "', argument " "1"" of type '" "Uuid *""'"); 
  }
  arg1 = reinterpret_cast< Uuid * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_Uuid) /* defines _wrap_delete_Uuid_destructor_closure */

SWIGINTERN int _wrap_new_CounterDescription__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  CounterDescription *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (CounterDescription *)new CounterDescription();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CounterDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_CounterDescription__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  CounterDescription *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_CounterDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CounterDescription" "', argument " "1"" of type '" "CounterDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CounterDescription" "', argument " "1"" of type '" "CounterDescription const &""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  result = (CounterDescription *)new CounterDescription((CounterDescription const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CounterDescription, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_CounterDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_CounterDescription",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CounterDescription__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_CounterDescription__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CounterDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CounterDescription::CounterDescription()\n"
    "    CounterDescription::CounterDescription(CounterDescription const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_CounterDescription_counter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_counter_set" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CounterDescription_counter_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->counter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_counter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterDescription_counter_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_counter_get" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  result = (uint32_t) ((arg1)->counter);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_name_set" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CounterDescription_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterDescription_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_name_get" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_category_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_category_set" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CounterDescription_category_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->category = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_category_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterDescription_category_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_category_get" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  result =  ((arg1)->category);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_description_set" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'CounterDescription_description_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->description = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterDescription_description_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_description_get" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  result =  ((arg1)->description);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_resultType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  CompType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_resultType_set" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CounterDescription_resultType_set" "', argument " "2"" of type '" "CompType""'");
  } 
  arg2 = static_cast< CompType >(val2);
  if (arg1) (arg1)->resultType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_resultType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompType result;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterDescription_resultType_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_resultType_get" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  result = (CompType) ((arg1)->resultType);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CompType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_resultByteWidth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_resultByteWidth_set" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CounterDescription_resultByteWidth_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->resultByteWidth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_resultByteWidth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterDescription_resultByteWidth_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_resultByteWidth_get" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  result = (uint32_t) ((arg1)->resultByteWidth);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_unit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  CounterUnit arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_unit_set" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CounterDescription_unit_set" "', argument " "2"" of type '" "CounterUnit""'");
  } 
  arg2 = static_cast< CounterUnit >(val2);
  if (arg1) (arg1)->unit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_unit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CounterUnit result;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterDescription_unit_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_unit_get" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  result = (CounterUnit) ((arg1)->unit);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CounterUnit->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_uuid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  Uuid *arg2 = (Uuid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_uuid_set" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_Uuid, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CounterDescription_uuid_set" "', argument " "2"" of type '" "Uuid *""'"); 
  }
  arg2 = reinterpret_cast< Uuid * >(argp2);
  if (arg1) (arg1)->uuid = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterDescription_uuid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Uuid *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterDescription_uuid_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterDescription_uuid_get" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  result = (Uuid *)& ((arg1)->uuid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Uuid, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CounterDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterDescription *arg1 = (CounterDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_CounterDescription",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterDescription, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CounterDescription" "', argument " "1"" of type '" "CounterDescription *""'"); 
  }
  arg1 = reinterpret_cast< CounterDescription * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CounterDescription) /* defines _wrap_delete_CounterDescription_destructor_closure */

SWIGINTERN PyObject *_wrap_CounterValue_f_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterValue *arg1 = (CounterValue *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterValue_f_set" "', argument " "1"" of type '" "CounterValue *""'"); 
  }
  arg1 = reinterpret_cast< CounterValue * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CounterValue_f_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->f = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterValue_f_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterValue *arg1 = (CounterValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterValue_f_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterValue_f_get" "', argument " "1"" of type '" "CounterValue *""'"); 
  }
  arg1 = reinterpret_cast< CounterValue * >(argp1);
  result = (float) ((arg1)->f);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterValue_d_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterValue *arg1 = (CounterValue *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterValue_d_set" "', argument " "1"" of type '" "CounterValue *""'"); 
  }
  arg1 = reinterpret_cast< CounterValue * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CounterValue_d_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->d = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterValue_d_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterValue *arg1 = (CounterValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterValue_d_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterValue_d_get" "', argument " "1"" of type '" "CounterValue *""'"); 
  }
  arg1 = reinterpret_cast< CounterValue * >(argp1);
  result = (double) ((arg1)->d);
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterValue_u32_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterValue *arg1 = (CounterValue *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterValue_u32_set" "', argument " "1"" of type '" "CounterValue *""'"); 
  }
  arg1 = reinterpret_cast< CounterValue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CounterValue_u32_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->u32 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterValue_u32_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterValue *arg1 = (CounterValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterValue_u32_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterValue_u32_get" "', argument " "1"" of type '" "CounterValue *""'"); 
  }
  arg1 = reinterpret_cast< CounterValue * >(argp1);
  result = (uint32_t) ((arg1)->u32);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterValue_u64_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterValue *arg1 = (CounterValue *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterValue_u64_set" "', argument " "1"" of type '" "CounterValue *""'"); 
  }
  arg1 = reinterpret_cast< CounterValue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CounterValue_u64_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->u64 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterValue_u64_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterValue *arg1 = (CounterValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterValue_u64_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterValue_u64_get" "', argument " "1"" of type '" "CounterValue *""'"); 
  }
  arg1 = reinterpret_cast< CounterValue * >(argp1);
  result = (uint64_t) ((arg1)->u64);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_CounterValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_CounterValue",0,0,0)) SWIG_fail;
  result = (CounterValue *)new CounterValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CounterValue, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_CounterValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterValue *arg1 = (CounterValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_CounterValue",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CounterValue" "', argument " "1"" of type '" "CounterValue *""'"); 
  }
  arg1 = reinterpret_cast< CounterValue * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CounterValue) /* defines _wrap_delete_CounterValue_destructor_closure */

SWIGINTERN int _wrap_new_CounterResult__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  CounterResult *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (CounterResult *)new CounterResult();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CounterResult, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_CounterResult__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CounterResult *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  CounterResult *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_CounterResult,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CounterResult" "', argument " "1"" of type '" "CounterResult const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CounterResult" "', argument " "1"" of type '" "CounterResult const &""'"); 
  }
  arg1 = reinterpret_cast< CounterResult * >(argp1);
  result = (CounterResult *)new CounterResult((CounterResult const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CounterResult, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_CounterResult__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  GPUCounter arg2 ;
  float arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  CounterResult *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CounterResult" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CounterResult" "', argument " "2"" of type '" "GPUCounter""'");
  } 
  arg2 = static_cast< GPUCounter >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CounterResult" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (CounterResult *)new CounterResult(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CounterResult, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_CounterResult__SWIG_3(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  GPUCounter arg2 ;
  double arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  CounterResult *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CounterResult" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CounterResult" "', argument " "2"" of type '" "GPUCounter""'");
  } 
  arg2 = static_cast< GPUCounter >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CounterResult" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (CounterResult *)new CounterResult(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CounterResult, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_CounterResult__SWIG_4(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  GPUCounter arg2 ;
  uint32_t arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  CounterResult *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CounterResult" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CounterResult" "', argument " "2"" of type '" "GPUCounter""'");
  } 
  arg2 = static_cast< GPUCounter >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CounterResult" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  result = (CounterResult *)new CounterResult(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CounterResult, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_CounterResult__SWIG_5(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  GPUCounter arg2 ;
  uint64_t arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  CounterResult *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CounterResult" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CounterResult" "', argument " "2"" of type '" "GPUCounter""'");
  } 
  arg2 = static_cast< GPUCounter >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CounterResult" "', argument " "3"" of type '" "uint64_t""'");
  } 
  arg3 = static_cast< uint64_t >(val3);
  result = (CounterResult *)new CounterResult(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CounterResult, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_CounterResult(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_CounterResult",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CounterResult__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_CounterResult__SWIG_1(self, argc, argv);
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    return _wrap_new_CounterResult__SWIG_4(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_CounterResult__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_float(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_new_CounterResult__SWIG_2(self, argc, argv);
  }
check_5:
  
  if (argc == 3) {
    return _wrap_new_CounterResult__SWIG_3(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CounterResult'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CounterResult::CounterResult()\n"
    "    CounterResult::CounterResult(CounterResult const &)\n"
    "    CounterResult::CounterResult(uint32_t,GPUCounter,float)\n"
    "    CounterResult::CounterResult(uint32_t,GPUCounter,double)\n"
    "    CounterResult::CounterResult(uint32_t,GPUCounter,uint32_t)\n"
    "    CounterResult::CounterResult(uint32_t,GPUCounter,uint64_t)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_CounterResult___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterResult *arg1 = (CounterResult *) 0 ;
  CounterResult *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterResult___lt__" "', argument " "1"" of type '" "CounterResult const *""'"); 
  }
  arg1 = reinterpret_cast< CounterResult * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_CounterResult,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CounterResult___lt__" "', argument " "2"" of type '" "CounterResult const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CounterResult___lt__" "', argument " "2"" of type '" "CounterResult const &""'"); 
  }
  arg2 = reinterpret_cast< CounterResult * >(argp2);
  result = (bool)((CounterResult const *)arg1)->operator <((CounterResult const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterResult_eventId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterResult *arg1 = (CounterResult *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterResult_eventId_set" "', argument " "1"" of type '" "CounterResult *""'"); 
  }
  arg1 = reinterpret_cast< CounterResult * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CounterResult_eventId_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->eventId = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterResult_eventId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterResult *arg1 = (CounterResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterResult_eventId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterResult_eventId_get" "', argument " "1"" of type '" "CounterResult *""'"); 
  }
  arg1 = reinterpret_cast< CounterResult * >(argp1);
  result = (uint32_t) ((arg1)->eventId);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterResult_counter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterResult *arg1 = (CounterResult *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterResult_counter_set" "', argument " "1"" of type '" "CounterResult *""'"); 
  }
  arg1 = reinterpret_cast< CounterResult * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CounterResult_counter_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->counter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterResult_counter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterResult *arg1 = (CounterResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterResult_counter_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterResult_counter_get" "', argument " "1"" of type '" "CounterResult *""'"); 
  }
  arg1 = reinterpret_cast< CounterResult * >(argp1);
  result = (uint32_t) ((arg1)->counter);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterResult_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterResult *arg1 = (CounterResult *) 0 ;
  CounterValue *arg2 = (CounterValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterResult_value_set" "', argument " "1"" of type '" "CounterResult *""'"); 
  }
  arg1 = reinterpret_cast< CounterResult * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_CounterValue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CounterResult_value_set" "', argument " "2"" of type '" "CounterValue *""'"); 
  }
  arg2 = reinterpret_cast< CounterValue * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterResult_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterResult *arg1 = (CounterResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CounterValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"CounterResult_value_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterResult_value_get" "', argument " "1"" of type '" "CounterResult *""'"); 
  }
  arg1 = reinterpret_cast< CounterResult * >(argp1);
  result = (CounterValue *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CounterValue, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterResult___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterResult *arg1 = (CounterResult *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterResult___eq__" "', argument " "1"" of type '" "CounterResult *""'"); 
  }
  arg1 = reinterpret_cast< CounterResult * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)CounterResult___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CounterResult___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterResult *arg1 = (CounterResult *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CounterResult___ne__" "', argument " "1"" of type '" "CounterResult *""'"); 
  }
  arg1 = reinterpret_cast< CounterResult * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)CounterResult___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CounterResult(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterResult *arg1 = (CounterResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_CounterResult",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterResult, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CounterResult" "', argument " "1"" of type '" "CounterResult *""'"); 
  }
  arg1 = reinterpret_cast< CounterResult * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CounterResult) /* defines _wrap_delete_CounterResult_destructor_closure */

SWIGINTERN PyObject *_wrap_PixelValue_floatValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelValue *arg1 = (PixelValue *) 0 ;
  rdcfixedarray< float,4 > *arg2 = (rdcfixedarray< float,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelValue_floatValue_set" "', argument " "1"" of type '" "PixelValue *""'"); 
  }
  arg1 = reinterpret_cast< PixelValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'PixelValue_floatValue_set' argument 2 of type 'rdcfixedarray< float,4 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'PixelValue_floatValue_set' argument 2 of type 'rdcfixedarray< float,4 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->floatValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelValue_floatValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelValue *arg1 = (PixelValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< float,4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelValue_floatValue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelValue_floatValue_get" "', argument " "1"" of type '" "PixelValue *""'"); 
  }
  arg1 = reinterpret_cast< PixelValue * >(argp1);
  result = (rdcfixedarray< float,4 > *)& ((arg1)->floatValue);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelValue_uintValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelValue *arg1 = (PixelValue *) 0 ;
  rdcfixedarray< uint32_t,4 > *arg2 = (rdcfixedarray< uint32_t,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelValue_uintValue_set" "', argument " "1"" of type '" "PixelValue *""'"); 
  }
  arg1 = reinterpret_cast< PixelValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'PixelValue_uintValue_set' argument 2 of type 'rdcfixedarray< uint32_t,4 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'PixelValue_uintValue_set' argument 2 of type 'rdcfixedarray< uint32_t,4 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->uintValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelValue_uintValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelValue *arg1 = (PixelValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint32_t,4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelValue_uintValue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelValue_uintValue_get" "', argument " "1"" of type '" "PixelValue *""'"); 
  }
  arg1 = reinterpret_cast< PixelValue * >(argp1);
  result = (rdcfixedarray< uint32_t,4 > *)& ((arg1)->uintValue);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelValue_intValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelValue *arg1 = (PixelValue *) 0 ;
  rdcfixedarray< int32_t,4 > *arg2 = (rdcfixedarray< int32_t,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelValue_intValue_set" "', argument " "1"" of type '" "PixelValue *""'"); 
  }
  arg1 = reinterpret_cast< PixelValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'PixelValue_intValue_set' argument 2 of type 'rdcfixedarray< int32_t,4 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'PixelValue_intValue_set' argument 2 of type 'rdcfixedarray< int32_t,4 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->intValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelValue_intValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelValue *arg1 = (PixelValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< int32_t,4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelValue_intValue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelValue_intValue_get" "', argument " "1"" of type '" "PixelValue *""'"); 
  }
  arg1 = reinterpret_cast< PixelValue * >(argp1);
  result = (rdcfixedarray< int32_t,4 > *)& ((arg1)->intValue);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_PixelValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_PixelValue",0,0,0)) SWIG_fail;
  result = (PixelValue *)new PixelValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PixelValue, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_PixelValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelValue *arg1 = (PixelValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_PixelValue",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PixelValue" "', argument " "1"" of type '" "PixelValue *""'"); 
  }
  arg1 = reinterpret_cast< PixelValue * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_PixelValue) /* defines _wrap_delete_PixelValue_destructor_closure */

SWIGINTERN int _wrap_new_ModificationValue__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ModificationValue *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ModificationValue *)new ModificationValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModificationValue, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ModificationValue__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ModificationValue *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ModificationValue *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ModificationValue,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ModificationValue" "', argument " "1"" of type '" "ModificationValue const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ModificationValue" "', argument " "1"" of type '" "ModificationValue const &""'"); 
  }
  arg1 = reinterpret_cast< ModificationValue * >(argp1);
  result = (ModificationValue *)new ModificationValue((ModificationValue const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModificationValue, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ModificationValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ModificationValue",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ModificationValue__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ModificationValue__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ModificationValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ModificationValue::ModificationValue()\n"
    "    ModificationValue::ModificationValue(ModificationValue const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ModificationValue___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModificationValue *arg1 = (ModificationValue *) 0 ;
  ModificationValue *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModificationValue___eq__" "', argument " "1"" of type '" "ModificationValue const *""'"); 
  }
  arg1 = reinterpret_cast< ModificationValue * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ModificationValue,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModificationValue___eq__" "', argument " "2"" of type '" "ModificationValue const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModificationValue___eq__" "', argument " "2"" of type '" "ModificationValue const &""'"); 
  }
  arg2 = reinterpret_cast< ModificationValue * >(argp2);
  result = (bool)((ModificationValue const *)arg1)->operator ==((ModificationValue const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModificationValue___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModificationValue *arg1 = (ModificationValue *) 0 ;
  ModificationValue *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModificationValue___lt__" "', argument " "1"" of type '" "ModificationValue const *""'"); 
  }
  arg1 = reinterpret_cast< ModificationValue * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ModificationValue,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModificationValue___lt__" "', argument " "2"" of type '" "ModificationValue const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModificationValue___lt__" "', argument " "2"" of type '" "ModificationValue const &""'"); 
  }
  arg2 = reinterpret_cast< ModificationValue * >(argp2);
  result = (bool)((ModificationValue const *)arg1)->operator <((ModificationValue const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModificationValue_col_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModificationValue *arg1 = (ModificationValue *) 0 ;
  PixelValue *arg2 = (PixelValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModificationValue_col_set" "', argument " "1"" of type '" "ModificationValue *""'"); 
  }
  arg1 = reinterpret_cast< ModificationValue * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_PixelValue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModificationValue_col_set" "', argument " "2"" of type '" "PixelValue *""'"); 
  }
  arg2 = reinterpret_cast< PixelValue * >(argp2);
  if (arg1) (arg1)->col = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModificationValue_col_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModificationValue *arg1 = (ModificationValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PixelValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ModificationValue_col_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModificationValue_col_get" "', argument " "1"" of type '" "ModificationValue *""'"); 
  }
  arg1 = reinterpret_cast< ModificationValue * >(argp1);
  result = (PixelValue *)& ((arg1)->col);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PixelValue, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModificationValue_depth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModificationValue *arg1 = (ModificationValue *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModificationValue_depth_set" "', argument " "1"" of type '" "ModificationValue *""'"); 
  }
  arg1 = reinterpret_cast< ModificationValue * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModificationValue_depth_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->depth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModificationValue_depth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModificationValue *arg1 = (ModificationValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"ModificationValue_depth_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModificationValue_depth_get" "', argument " "1"" of type '" "ModificationValue *""'"); 
  }
  arg1 = reinterpret_cast< ModificationValue * >(argp1);
  result = (float) ((arg1)->depth);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModificationValue_stencil_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModificationValue *arg1 = (ModificationValue *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModificationValue_stencil_set" "', argument " "1"" of type '" "ModificationValue *""'"); 
  }
  arg1 = reinterpret_cast< ModificationValue * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModificationValue_stencil_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->stencil = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModificationValue_stencil_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModificationValue *arg1 = (ModificationValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ModificationValue_stencil_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModificationValue_stencil_get" "', argument " "1"" of type '" "ModificationValue *""'"); 
  }
  arg1 = reinterpret_cast< ModificationValue * >(argp1);
  result = (int32_t) ((arg1)->stencil);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModificationValue_IsValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModificationValue *arg1 = (ModificationValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ModificationValue_IsValid",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModificationValue_IsValid" "', argument " "1"" of type '" "ModificationValue const *""'"); 
  }
  arg1 = reinterpret_cast< ModificationValue * >(argp1);
  result = (bool)((ModificationValue const *)arg1)->IsValid();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModificationValue_SetInvalid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModificationValue *arg1 = (ModificationValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ModificationValue_SetInvalid",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModificationValue_SetInvalid" "', argument " "1"" of type '" "ModificationValue *""'"); 
  }
  arg1 = reinterpret_cast< ModificationValue * >(argp1);
  (arg1)->SetInvalid();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ModificationValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModificationValue *arg1 = (ModificationValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ModificationValue",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ModificationValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModificationValue" "', argument " "1"" of type '" "ModificationValue *""'"); 
  }
  arg1 = reinterpret_cast< ModificationValue * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ModificationValue) /* defines _wrap_delete_ModificationValue_destructor_closure */

SWIGINTERN int _wrap_new_PixelModification__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  PixelModification *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (PixelModification *)new PixelModification();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PixelModification, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_PixelModification__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PixelModification *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_PixelModification,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PixelModification" "', argument " "1"" of type '" "PixelModification const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PixelModification" "', argument " "1"" of type '" "PixelModification const &""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (PixelModification *)new PixelModification((PixelModification const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PixelModification, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_PixelModification(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PixelModification",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_PixelModification__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_PixelModification__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PixelModification'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PixelModification::PixelModification()\n"
    "    PixelModification::PixelModification(PixelModification const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_PixelModification___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  PixelModification *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification___lt__" "', argument " "1"" of type '" "PixelModification const *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_PixelModification,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PixelModification___lt__" "', argument " "2"" of type '" "PixelModification const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PixelModification___lt__" "', argument " "2"" of type '" "PixelModification const &""'"); 
  }
  arg2 = reinterpret_cast< PixelModification * >(argp2);
  result = (bool)((PixelModification const *)arg1)->operator <((PixelModification const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_eventId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_eventId_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_eventId_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->eventId = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_eventId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_eventId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_eventId_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (uint32_t) ((arg1)->eventId);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_directShaderWrite_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_directShaderWrite_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_directShaderWrite_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->directShaderWrite = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_directShaderWrite_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_directShaderWrite_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_directShaderWrite_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (bool) ((arg1)->directShaderWrite);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_unboundPS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_unboundPS_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_unboundPS_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->unboundPS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_unboundPS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_unboundPS_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_unboundPS_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (bool) ((arg1)->unboundPS);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_fragIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_fragIndex_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_fragIndex_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->fragIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_fragIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_fragIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_fragIndex_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (uint32_t) ((arg1)->fragIndex);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_primitiveID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_primitiveID_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_primitiveID_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->primitiveID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_primitiveID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_primitiveID_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_primitiveID_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (uint32_t) ((arg1)->primitiveID);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_preMod_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  ModificationValue *arg2 = (ModificationValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_preMod_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PixelModification_preMod_set" "', argument " "2"" of type '" "ModificationValue *""'"); 
  }
  arg2 = reinterpret_cast< ModificationValue * >(argp2);
  if (arg1) (arg1)->preMod = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_preMod_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ModificationValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_preMod_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_preMod_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (ModificationValue *)& ((arg1)->preMod);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_shaderOut_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  ModificationValue *arg2 = (ModificationValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_shaderOut_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PixelModification_shaderOut_set" "', argument " "2"" of type '" "ModificationValue *""'"); 
  }
  arg2 = reinterpret_cast< ModificationValue * >(argp2);
  if (arg1) (arg1)->shaderOut = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_shaderOut_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ModificationValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_shaderOut_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_shaderOut_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (ModificationValue *)& ((arg1)->shaderOut);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_postMod_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  ModificationValue *arg2 = (ModificationValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_postMod_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PixelModification_postMod_set" "', argument " "2"" of type '" "ModificationValue *""'"); 
  }
  arg2 = reinterpret_cast< ModificationValue * >(argp2);
  if (arg1) (arg1)->postMod = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_postMod_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ModificationValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_postMod_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_postMod_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (ModificationValue *)& ((arg1)->postMod);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModificationValue, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_sampleMasked_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_sampleMasked_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_sampleMasked_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->sampleMasked = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_sampleMasked_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_sampleMasked_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_sampleMasked_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (bool) ((arg1)->sampleMasked);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_backfaceCulled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_backfaceCulled_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_backfaceCulled_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->backfaceCulled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_backfaceCulled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_backfaceCulled_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_backfaceCulled_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (bool) ((arg1)->backfaceCulled);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_depthClipped_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_depthClipped_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_depthClipped_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthClipped = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_depthClipped_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_depthClipped_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_depthClipped_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (bool) ((arg1)->depthClipped);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_depthBoundsFailed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_depthBoundsFailed_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_depthBoundsFailed_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthBoundsFailed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_depthBoundsFailed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_depthBoundsFailed_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_depthBoundsFailed_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (bool) ((arg1)->depthBoundsFailed);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_viewClipped_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_viewClipped_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_viewClipped_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->viewClipped = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_viewClipped_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_viewClipped_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_viewClipped_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (bool) ((arg1)->viewClipped);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_scissorClipped_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_scissorClipped_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_scissorClipped_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->scissorClipped = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_scissorClipped_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_scissorClipped_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_scissorClipped_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (bool) ((arg1)->scissorClipped);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_shaderDiscarded_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_shaderDiscarded_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_shaderDiscarded_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->shaderDiscarded = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_shaderDiscarded_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_shaderDiscarded_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_shaderDiscarded_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (bool) ((arg1)->shaderDiscarded);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_depthTestFailed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_depthTestFailed_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_depthTestFailed_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthTestFailed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_depthTestFailed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_depthTestFailed_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_depthTestFailed_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (bool) ((arg1)->depthTestFailed);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_stencilTestFailed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_stencilTestFailed_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_stencilTestFailed_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->stencilTestFailed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_stencilTestFailed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_stencilTestFailed_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_stencilTestFailed_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (bool) ((arg1)->stencilTestFailed);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_predicationSkipped_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_predicationSkipped_set" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_predicationSkipped_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->predicationSkipped = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_predicationSkipped_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_predicationSkipped_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_predicationSkipped_get" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (bool) ((arg1)->predicationSkipped);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_Passed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_Passed",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_Passed" "', argument " "1"" of type '" "PixelModification const *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  result = (bool)((PixelModification const *)arg1)->Passed();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification_CheckDepthTestQuantised(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  uint32_t arg2 ;
  CompareFunction arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"PixelModification_CheckDepthTestQuantised",2,2,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification_CheckDepthTestQuantised" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelModification_CheckDepthTestQuantised" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PixelModification_CheckDepthTestQuantised" "', argument " "3"" of type '" "CompareFunction""'");
  } 
  arg3 = static_cast< CompareFunction >(val3);
  (arg1)->CheckDepthTestQuantised(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification___eq__" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)PixelModification___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PixelModification___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelModification___ne__" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)PixelModification___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PixelModification(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PixelModification *arg1 = (PixelModification *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_PixelModification",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PixelModification, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PixelModification" "', argument " "1"" of type '" "PixelModification *""'"); 
  }
  arg1 = reinterpret_cast< PixelModification * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_PixelModification) /* defines _wrap_delete_PixelModification_destructor_closure */

SWIGINTERN int _wrap_new_Thumbnail__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Thumbnail *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (Thumbnail *)new Thumbnail();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Thumbnail, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Thumbnail__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Thumbnail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Thumbnail *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Thumbnail,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Thumbnail" "', argument " "1"" of type '" "Thumbnail const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Thumbnail" "', argument " "1"" of type '" "Thumbnail const &""'"); 
  }
  arg1 = reinterpret_cast< Thumbnail * >(argp1);
  result = (Thumbnail *)new Thumbnail((Thumbnail const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Thumbnail, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_Thumbnail(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_Thumbnail",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Thumbnail__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_Thumbnail__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Thumbnail'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Thumbnail::Thumbnail()\n"
    "    Thumbnail::Thumbnail(Thumbnail const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_Thumbnail_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Thumbnail *arg1 = (Thumbnail *) 0 ;
  FileType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Thumbnail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thumbnail_type_set" "', argument " "1"" of type '" "Thumbnail *""'"); 
  }
  arg1 = reinterpret_cast< Thumbnail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Thumbnail_type_set" "', argument " "2"" of type '" "FileType""'");
  } 
  arg2 = static_cast< FileType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thumbnail_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Thumbnail *arg1 = (Thumbnail *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FileType result;
  
  if (!SWIG_Python_UnpackTuple(args,"Thumbnail_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Thumbnail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thumbnail_type_get" "', argument " "1"" of type '" "Thumbnail *""'"); 
  }
  arg1 = reinterpret_cast< Thumbnail * >(argp1);
  result = (FileType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_FileType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thumbnail_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Thumbnail *arg1 = (Thumbnail *) 0 ;
  bytebuf *arg2 = (bytebuf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bytebuf temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Thumbnail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thumbnail_data_set" "', argument " "1"" of type '" "Thumbnail *""'"); 
  }
  arg1 = reinterpret_cast< Thumbnail * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'Thumbnail_data_set' argument 2 of type 'bytebuf'"); 
    }
  }
  if (arg1) (arg1)->data = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thumbnail_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Thumbnail *arg1 = (Thumbnail *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bytebuf *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"Thumbnail_data_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Thumbnail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thumbnail_data_get" "', argument " "1"" of type '" "Thumbnail *""'"); 
  }
  arg1 = reinterpret_cast< Thumbnail * >(argp1);
  result = (bytebuf *)& ((arg1)->data);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thumbnail_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Thumbnail *arg1 = (Thumbnail *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Thumbnail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thumbnail_width_set" "', argument " "1"" of type '" "Thumbnail *""'"); 
  }
  arg1 = reinterpret_cast< Thumbnail * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Thumbnail_width_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thumbnail_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Thumbnail *arg1 = (Thumbnail *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Thumbnail_width_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Thumbnail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thumbnail_width_get" "', argument " "1"" of type '" "Thumbnail *""'"); 
  }
  arg1 = reinterpret_cast< Thumbnail * >(argp1);
  result = (uint32_t) ((arg1)->width);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thumbnail_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Thumbnail *arg1 = (Thumbnail *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Thumbnail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thumbnail_height_set" "', argument " "1"" of type '" "Thumbnail *""'"); 
  }
  arg1 = reinterpret_cast< Thumbnail * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Thumbnail_height_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thumbnail_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Thumbnail *arg1 = (Thumbnail *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"Thumbnail_height_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Thumbnail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thumbnail_height_get" "', argument " "1"" of type '" "Thumbnail *""'"); 
  }
  arg1 = reinterpret_cast< Thumbnail * >(argp1);
  result = (uint32_t) ((arg1)->height);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Thumbnail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Thumbnail *arg1 = (Thumbnail *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_Thumbnail",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Thumbnail, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Thumbnail" "', argument " "1"" of type '" "Thumbnail *""'"); 
  }
  arg1 = reinterpret_cast< Thumbnail * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_Thumbnail) /* defines _wrap_delete_Thumbnail_destructor_closure */

SWIGINTERN int _wrap_new_DebugPixelInputs__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  DebugPixelInputs *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (DebugPixelInputs *)new DebugPixelInputs();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DebugPixelInputs, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DebugPixelInputs__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DebugPixelInputs *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DebugPixelInputs *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DebugPixelInputs,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DebugPixelInputs" "', argument " "1"" of type '" "DebugPixelInputs const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DebugPixelInputs" "', argument " "1"" of type '" "DebugPixelInputs const &""'"); 
  }
  arg1 = reinterpret_cast< DebugPixelInputs * >(argp1);
  result = (DebugPixelInputs *)new DebugPixelInputs((DebugPixelInputs const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DebugPixelInputs, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DebugPixelInputs(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DebugPixelInputs",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DebugPixelInputs__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_DebugPixelInputs__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DebugPixelInputs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DebugPixelInputs::DebugPixelInputs()\n"
    "    DebugPixelInputs::DebugPixelInputs(DebugPixelInputs const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_DebugPixelInputs_sample_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugPixelInputs *arg1 = (DebugPixelInputs *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugPixelInputs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugPixelInputs_sample_set" "', argument " "1"" of type '" "DebugPixelInputs *""'"); 
  }
  arg1 = reinterpret_cast< DebugPixelInputs * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DebugPixelInputs_sample_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sample = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugPixelInputs_sample_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugPixelInputs *arg1 = (DebugPixelInputs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DebugPixelInputs_sample_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugPixelInputs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugPixelInputs_sample_get" "', argument " "1"" of type '" "DebugPixelInputs *""'"); 
  }
  arg1 = reinterpret_cast< DebugPixelInputs * >(argp1);
  result = (uint32_t) ((arg1)->sample);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugPixelInputs_primitive_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugPixelInputs *arg1 = (DebugPixelInputs *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugPixelInputs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugPixelInputs_primitive_set" "', argument " "1"" of type '" "DebugPixelInputs *""'"); 
  }
  arg1 = reinterpret_cast< DebugPixelInputs * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DebugPixelInputs_primitive_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->primitive = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugPixelInputs_primitive_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugPixelInputs *arg1 = (DebugPixelInputs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DebugPixelInputs_primitive_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugPixelInputs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugPixelInputs_primitive_get" "', argument " "1"" of type '" "DebugPixelInputs *""'"); 
  }
  arg1 = reinterpret_cast< DebugPixelInputs * >(argp1);
  result = (uint32_t) ((arg1)->primitive);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugPixelInputs_view_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugPixelInputs *arg1 = (DebugPixelInputs *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugPixelInputs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugPixelInputs_view_set" "', argument " "1"" of type '" "DebugPixelInputs *""'"); 
  }
  arg1 = reinterpret_cast< DebugPixelInputs * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DebugPixelInputs_view_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->view = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugPixelInputs_view_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugPixelInputs *arg1 = (DebugPixelInputs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DebugPixelInputs_view_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugPixelInputs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugPixelInputs_view_get" "', argument " "1"" of type '" "DebugPixelInputs *""'"); 
  }
  arg1 = reinterpret_cast< DebugPixelInputs * >(argp1);
  result = (uint32_t) ((arg1)->view);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DebugPixelInputs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugPixelInputs *arg1 = (DebugPixelInputs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DebugPixelInputs",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugPixelInputs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DebugPixelInputs" "', argument " "1"" of type '" "DebugPixelInputs *""'"); 
  }
  arg1 = reinterpret_cast< DebugPixelInputs * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DebugPixelInputs) /* defines _wrap_delete_DebugPixelInputs_destructor_closure */

SWIGINTERN int _wrap_new_GLVertexAttribute__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::VertexAttribute *)new GLPipe::VertexAttribute();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__VertexAttribute, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLVertexAttribute__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::VertexAttribute *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__VertexAttribute,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLVertexAttribute" "', argument " "1"" of type '" "GLPipe::VertexAttribute const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLVertexAttribute" "', argument " "1"" of type '" "GLPipe::VertexAttribute const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  result = (GLPipe::VertexAttribute *)new GLPipe::VertexAttribute((GLPipe::VertexAttribute const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__VertexAttribute, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLVertexAttribute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLVertexAttribute",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLVertexAttribute__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLVertexAttribute__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLVertexAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::VertexAttribute::VertexAttribute()\n"
    "    GLPipe::VertexAttribute::VertexAttribute(GLPipe::VertexAttribute const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  GLPipe::VertexAttribute *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute___eq__" "', argument " "1"" of type '" "GLPipe::VertexAttribute const *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_GLPipe__VertexAttribute,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLVertexAttribute___eq__" "', argument " "2"" of type '" "GLPipe::VertexAttribute const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GLVertexAttribute___eq__" "', argument " "2"" of type '" "GLPipe::VertexAttribute const &""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::VertexAttribute * >(argp2);
  result = (bool)((GLPipe::VertexAttribute const *)arg1)->operator ==((GLPipe::VertexAttribute const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  GLPipe::VertexAttribute *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute___lt__" "', argument " "1"" of type '" "GLPipe::VertexAttribute const *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_GLPipe__VertexAttribute,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLVertexAttribute___lt__" "', argument " "2"" of type '" "GLPipe::VertexAttribute const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GLVertexAttribute___lt__" "', argument " "2"" of type '" "GLPipe::VertexAttribute const &""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::VertexAttribute * >(argp2);
  result = (bool)((GLPipe::VertexAttribute const *)arg1)->operator <((GLPipe::VertexAttribute const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_enabled_set" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLVertexAttribute_enabled_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexAttribute_enabled_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_enabled_get" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  result = (bool) ((arg1)->enabled);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_floatCast_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_floatCast_set" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLVertexAttribute_floatCast_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->floatCast = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_floatCast_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexAttribute_floatCast_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_floatCast_get" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  result = (bool) ((arg1)->floatCast);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_boundShaderInput_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_boundShaderInput_set" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLVertexAttribute_boundShaderInput_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->boundShaderInput = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_boundShaderInput_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexAttribute_boundShaderInput_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_boundShaderInput_get" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  result = (int32_t) ((arg1)->boundShaderInput);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_format_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  ResourceFormat *arg2 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_format_set" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLVertexAttribute_format_set" "', argument " "2"" of type '" "ResourceFormat *""'"); 
  }
  arg2 = reinterpret_cast< ResourceFormat * >(argp2);
  if (arg1) (arg1)->format = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_format_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceFormat *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexAttribute_format_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_format_get" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  result = (ResourceFormat *)& ((arg1)->format);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_genericValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  PixelValue *arg2 = (PixelValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_genericValue_set" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_PixelValue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLVertexAttribute_genericValue_set" "', argument " "2"" of type '" "PixelValue *""'"); 
  }
  arg2 = reinterpret_cast< PixelValue * >(argp2);
  if (arg1) (arg1)->genericValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_genericValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PixelValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexAttribute_genericValue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_genericValue_get" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  result = (PixelValue *)& ((arg1)->genericValue);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PixelValue, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_vertexBufferSlot_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_vertexBufferSlot_set" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLVertexAttribute_vertexBufferSlot_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->vertexBufferSlot = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_vertexBufferSlot_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexAttribute_vertexBufferSlot_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_vertexBufferSlot_get" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  result = (uint32_t) ((arg1)->vertexBufferSlot);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_byteOffset_set" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLVertexAttribute_byteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexAttribute_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexAttribute_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexAttribute_byteOffset_get" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  result = (uint32_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLVertexAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexAttribute *arg1 = (GLPipe::VertexAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLVertexAttribute",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLVertexAttribute" "', argument " "1"" of type '" "GLPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexAttribute * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLVertexAttribute) /* defines _wrap_delete_GLVertexAttribute_destructor_closure */

SWIGINTERN int _wrap_new_GLVertexBuffer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::VertexBuffer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::VertexBuffer *)new GLPipe::VertexBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__VertexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLVertexBuffer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::VertexBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::VertexBuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLVertexBuffer" "', argument " "1"" of type '" "GLPipe::VertexBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLVertexBuffer" "', argument " "1"" of type '" "GLPipe::VertexBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexBuffer * >(argp1);
  result = (GLPipe::VertexBuffer *)new GLPipe::VertexBuffer((GLPipe::VertexBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__VertexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLVertexBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLVertexBuffer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLVertexBuffer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLVertexBuffer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLVertexBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::VertexBuffer::VertexBuffer()\n"
    "    GLPipe::VertexBuffer::VertexBuffer(GLPipe::VertexBuffer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLVertexBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexBuffer *arg1 = (GLPipe::VertexBuffer *) 0 ;
  GLPipe::VertexBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexBuffer___eq__" "', argument " "1"" of type '" "GLPipe::VertexBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_GLPipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLVertexBuffer___eq__" "', argument " "2"" of type '" "GLPipe::VertexBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GLVertexBuffer___eq__" "', argument " "2"" of type '" "GLPipe::VertexBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::VertexBuffer * >(argp2);
  result = (bool)((GLPipe::VertexBuffer const *)arg1)->operator ==((GLPipe::VertexBuffer const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexBuffer *arg1 = (GLPipe::VertexBuffer *) 0 ;
  GLPipe::VertexBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexBuffer___lt__" "', argument " "1"" of type '" "GLPipe::VertexBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_GLPipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLVertexBuffer___lt__" "', argument " "2"" of type '" "GLPipe::VertexBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GLVertexBuffer___lt__" "', argument " "2"" of type '" "GLPipe::VertexBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::VertexBuffer * >(argp2);
  result = (bool)((GLPipe::VertexBuffer const *)arg1)->operator <((GLPipe::VertexBuffer const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexBuffer_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexBuffer *arg1 = (GLPipe::VertexBuffer *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexBuffer_resourceId_set" "', argument " "1"" of type '" "GLPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLVertexBuffer_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexBuffer_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexBuffer *arg1 = (GLPipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexBuffer_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexBuffer_resourceId_get" "', argument " "1"" of type '" "GLPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexBuffer * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexBuffer_byteStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexBuffer *arg1 = (GLPipe::VertexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexBuffer_byteStride_set" "', argument " "1"" of type '" "GLPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLVertexBuffer_byteStride_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexBuffer_byteStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexBuffer *arg1 = (GLPipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexBuffer_byteStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexBuffer_byteStride_get" "', argument " "1"" of type '" "GLPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteStride);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexBuffer_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexBuffer *arg1 = (GLPipe::VertexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexBuffer_byteOffset_set" "', argument " "1"" of type '" "GLPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLVertexBuffer_byteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexBuffer_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexBuffer *arg1 = (GLPipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexBuffer_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexBuffer_byteOffset_get" "', argument " "1"" of type '" "GLPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexBuffer_instanceDivisor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexBuffer *arg1 = (GLPipe::VertexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexBuffer_instanceDivisor_set" "', argument " "1"" of type '" "GLPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLVertexBuffer_instanceDivisor_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->instanceDivisor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexBuffer_instanceDivisor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexBuffer *arg1 = (GLPipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexBuffer_instanceDivisor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexBuffer_instanceDivisor_get" "', argument " "1"" of type '" "GLPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->instanceDivisor);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLVertexBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexBuffer *arg1 = (GLPipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLVertexBuffer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLVertexBuffer" "', argument " "1"" of type '" "GLPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexBuffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLVertexBuffer) /* defines _wrap_delete_GLVertexBuffer_destructor_closure */

SWIGINTERN int _wrap_new_GLVertexInput__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::VertexInput *)new GLPipe::VertexInput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__VertexInput, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLVertexInput__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::VertexInput *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__VertexInput,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLVertexInput" "', argument " "1"" of type '" "GLPipe::VertexInput const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLVertexInput" "', argument " "1"" of type '" "GLPipe::VertexInput const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  result = (GLPipe::VertexInput *)new GLPipe::VertexInput((GLPipe::VertexInput const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__VertexInput, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLVertexInput(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLVertexInput",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLVertexInput__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLVertexInput__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLVertexInput'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::VertexInput::VertexInput()\n"
    "    GLPipe::VertexInput::VertexInput(GLPipe::VertexInput const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_vertexArrayObject_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_vertexArrayObject_set" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLVertexInput_vertexArrayObject_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->vertexArrayObject = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_vertexArrayObject_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexInput_vertexArrayObject_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_vertexArrayObject_get" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  result = (ResourceId *)& ((arg1)->vertexArrayObject);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_attributes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  rdcarray< GLPipe::VertexAttribute > *arg2 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_attributes_set" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLVertexInput_attributes_set' argument 2 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLVertexInput_attributes_set' argument 2 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->attributes = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_attributes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< GLPipe::VertexAttribute > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexInput_attributes_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_attributes_get" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  result = (rdcarray< GLPipe::VertexAttribute > *)& ((arg1)->attributes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_GLPipe__VertexAttribute_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_vertexBuffers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  rdcarray< GLPipe::VertexBuffer > *arg2 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_vertexBuffers_set" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLVertexInput_vertexBuffers_set' argument 2 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLVertexInput_vertexBuffers_set' argument 2 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->vertexBuffers = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_vertexBuffers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< GLPipe::VertexBuffer > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexInput_vertexBuffers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_vertexBuffers_get" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  result = (rdcarray< GLPipe::VertexBuffer > *)& ((arg1)->vertexBuffers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_GLPipe__VertexBuffer_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_indexBuffer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_indexBuffer_set" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLVertexInput_indexBuffer_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->indexBuffer = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_indexBuffer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexInput_indexBuffer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_indexBuffer_get" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  result = (ResourceId *)& ((arg1)->indexBuffer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_indexByteStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_indexByteStride_set" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLVertexInput_indexByteStride_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->indexByteStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_indexByteStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexInput_indexByteStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_indexByteStride_get" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  result = (uint32_t) ((arg1)->indexByteStride);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_topology_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  Topology arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_topology_set" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLVertexInput_topology_set" "', argument " "2"" of type '" "Topology""'");
  } 
  arg2 = static_cast< Topology >(val2);
  if (arg1) (arg1)->topology = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_topology_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Topology result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexInput_topology_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_topology_get" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  result = (Topology) ((arg1)->topology);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_Topology->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_primitiveRestart_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_primitiveRestart_set" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLVertexInput_primitiveRestart_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->primitiveRestart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_primitiveRestart_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexInput_primitiveRestart_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_primitiveRestart_get" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  result = (bool) ((arg1)->primitiveRestart);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_restartIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_restartIndex_set" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLVertexInput_restartIndex_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->restartIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_restartIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexInput_restartIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_restartIndex_get" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  result = (uint32_t) ((arg1)->restartIndex);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_provokingVertexLast_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_provokingVertexLast_set" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLVertexInput_provokingVertexLast_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->provokingVertexLast = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLVertexInput_provokingVertexLast_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLVertexInput_provokingVertexLast_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLVertexInput_provokingVertexLast_get" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  result = (bool) ((arg1)->provokingVertexLast);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLVertexInput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::VertexInput *arg1 = (GLPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLVertexInput",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__VertexInput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLVertexInput" "', argument " "1"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::VertexInput * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLVertexInput) /* defines _wrap_delete_GLVertexInput_destructor_closure */

SWIGINTERN int _wrap_new_GLShader__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::Shader *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::Shader *)new GLPipe::Shader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Shader, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLShader__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::Shader *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::Shader *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__Shader,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLShader" "', argument " "1"" of type '" "GLPipe::Shader const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLShader" "', argument " "1"" of type '" "GLPipe::Shader const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Shader * >(argp1);
  result = (GLPipe::Shader *)new GLPipe::Shader((GLPipe::Shader const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Shader, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLShader(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLShader",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLShader__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLShader__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLShader'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::Shader::Shader()\n"
    "    GLPipe::Shader::Shader(GLPipe::Shader const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLShader_shaderResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Shader *arg1 = (GLPipe::Shader *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLShader_shaderResourceId_set" "', argument " "1"" of type '" "GLPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Shader * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLShader_shaderResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->shaderResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLShader_shaderResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Shader *arg1 = (GLPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLShader_shaderResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLShader_shaderResourceId_get" "', argument " "1"" of type '" "GLPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Shader * >(argp1);
  result = (ResourceId *)& ((arg1)->shaderResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLShader_programResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Shader *arg1 = (GLPipe::Shader *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLShader_programResourceId_set" "', argument " "1"" of type '" "GLPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Shader * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLShader_programResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->programResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLShader_programResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Shader *arg1 = (GLPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLShader_programResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLShader_programResourceId_get" "', argument " "1"" of type '" "GLPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Shader * >(argp1);
  result = (ResourceId *)& ((arg1)->programResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLShader_reflection_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Shader *arg1 = (GLPipe::Shader *) 0 ;
  ShaderReflection *arg2 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLShader_reflection_set" "', argument " "1"" of type '" "GLPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Shader * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderReflection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLShader_reflection_set" "', argument " "2"" of type '" "ShaderReflection const *""'"); 
  }
  arg2 = reinterpret_cast< ShaderReflection * >(argp2);
  if (arg1) (arg1)->reflection = (ShaderReflection const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLShader_reflection_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Shader *arg1 = (GLPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderReflection *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLShader_reflection_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLShader_reflection_get" "', argument " "1"" of type '" "GLPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Shader * >(argp1);
  result = (ShaderReflection *) ((arg1)->reflection);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLShader_stage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Shader *arg1 = (GLPipe::Shader *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLShader_stage_set" "', argument " "1"" of type '" "GLPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Shader * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLShader_stage_set" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  if (arg1) (arg1)->stage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLShader_stage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Shader *arg1 = (GLPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStage result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLShader_stage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLShader_stage_get" "', argument " "1"" of type '" "GLPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Shader * >(argp1);
  result = (ShaderStage) ((arg1)->stage);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLShader_subroutines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Shader *arg1 = (GLPipe::Shader *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLShader_subroutines_set" "', argument " "1"" of type '" "GLPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Shader * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLShader_subroutines_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLShader_subroutines_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->subroutines = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLShader_subroutines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Shader *arg1 = (GLPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLShader_subroutines_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLShader_subroutines_get" "', argument " "1"" of type '" "GLPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Shader * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->subroutines);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLShader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Shader *arg1 = (GLPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLShader",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Shader, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLShader" "', argument " "1"" of type '" "GLPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Shader * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLShader) /* defines _wrap_delete_GLShader_destructor_closure */

SWIGINTERN int _wrap_new_GLFixedVertexProcessing__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::FixedVertexProcessing *)new GLPipe::FixedVertexProcessing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__FixedVertexProcessing, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLFixedVertexProcessing__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::FixedVertexProcessing *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__FixedVertexProcessing,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLFixedVertexProcessing" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLFixedVertexProcessing" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  result = (GLPipe::FixedVertexProcessing *)new GLPipe::FixedVertexProcessing((GLPipe::FixedVertexProcessing const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__FixedVertexProcessing, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLFixedVertexProcessing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLFixedVertexProcessing",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLFixedVertexProcessing__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLFixedVertexProcessing__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLFixedVertexProcessing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::FixedVertexProcessing::FixedVertexProcessing()\n"
    "    GLPipe::FixedVertexProcessing::FixedVertexProcessing(GLPipe::FixedVertexProcessing const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLFixedVertexProcessing_defaultInnerLevel_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = (GLPipe::FixedVertexProcessing *) 0 ;
  rdcfixedarray< float,2 > *arg2 = (rdcfixedarray< float,2 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFixedVertexProcessing_defaultInnerLevel_set" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLFixedVertexProcessing_defaultInnerLevel_set' argument 2 of type 'rdcfixedarray< float,2 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLFixedVertexProcessing_defaultInnerLevel_set' argument 2 of type 'rdcfixedarray< float,2 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->defaultInnerLevel = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFixedVertexProcessing_defaultInnerLevel_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = (GLPipe::FixedVertexProcessing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< float,2 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFixedVertexProcessing_defaultInnerLevel_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFixedVertexProcessing_defaultInnerLevel_get" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  result = (rdcfixedarray< float,2 > *)& ((arg1)->defaultInnerLevel);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFixedVertexProcessing_defaultOuterLevel_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = (GLPipe::FixedVertexProcessing *) 0 ;
  rdcfixedarray< float,4 > *arg2 = (rdcfixedarray< float,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFixedVertexProcessing_defaultOuterLevel_set" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLFixedVertexProcessing_defaultOuterLevel_set' argument 2 of type 'rdcfixedarray< float,4 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLFixedVertexProcessing_defaultOuterLevel_set' argument 2 of type 'rdcfixedarray< float,4 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->defaultOuterLevel = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFixedVertexProcessing_defaultOuterLevel_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = (GLPipe::FixedVertexProcessing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< float,4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFixedVertexProcessing_defaultOuterLevel_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFixedVertexProcessing_defaultOuterLevel_get" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  result = (rdcfixedarray< float,4 > *)& ((arg1)->defaultOuterLevel);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFixedVertexProcessing_discard_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = (GLPipe::FixedVertexProcessing *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFixedVertexProcessing_discard_set" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLFixedVertexProcessing_discard_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->discard = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFixedVertexProcessing_discard_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = (GLPipe::FixedVertexProcessing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFixedVertexProcessing_discard_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFixedVertexProcessing_discard_get" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  result = (bool) ((arg1)->discard);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFixedVertexProcessing_clipPlanes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = (GLPipe::FixedVertexProcessing *) 0 ;
  rdcfixedarray< bool,8 > *arg2 = (rdcfixedarray< bool,8 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFixedVertexProcessing_clipPlanes_set" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLFixedVertexProcessing_clipPlanes_set' argument 2 of type 'rdcfixedarray< bool,8 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLFixedVertexProcessing_clipPlanes_set' argument 2 of type 'rdcfixedarray< bool,8 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->clipPlanes = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFixedVertexProcessing_clipPlanes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = (GLPipe::FixedVertexProcessing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< bool,8 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFixedVertexProcessing_clipPlanes_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFixedVertexProcessing_clipPlanes_get" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  result = (rdcfixedarray< bool,8 > *)& ((arg1)->clipPlanes);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFixedVertexProcessing_clipOriginLowerLeft_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = (GLPipe::FixedVertexProcessing *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFixedVertexProcessing_clipOriginLowerLeft_set" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLFixedVertexProcessing_clipOriginLowerLeft_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->clipOriginLowerLeft = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFixedVertexProcessing_clipOriginLowerLeft_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = (GLPipe::FixedVertexProcessing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFixedVertexProcessing_clipOriginLowerLeft_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFixedVertexProcessing_clipOriginLowerLeft_get" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  result = (bool) ((arg1)->clipOriginLowerLeft);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFixedVertexProcessing_clipNegativeOneToOne_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = (GLPipe::FixedVertexProcessing *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFixedVertexProcessing_clipNegativeOneToOne_set" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLFixedVertexProcessing_clipNegativeOneToOne_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->clipNegativeOneToOne = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFixedVertexProcessing_clipNegativeOneToOne_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = (GLPipe::FixedVertexProcessing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFixedVertexProcessing_clipNegativeOneToOne_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFixedVertexProcessing_clipNegativeOneToOne_get" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  result = (bool) ((arg1)->clipNegativeOneToOne);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLFixedVertexProcessing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FixedVertexProcessing *arg1 = (GLPipe::FixedVertexProcessing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLFixedVertexProcessing",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FixedVertexProcessing, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLFixedVertexProcessing" "', argument " "1"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLFixedVertexProcessing) /* defines _wrap_delete_GLFixedVertexProcessing_destructor_closure */

SWIGINTERN int _wrap_new_GLTextureCompleteness__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::TextureCompleteness *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::TextureCompleteness *)new GLPipe::TextureCompleteness();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__TextureCompleteness, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLTextureCompleteness__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::TextureCompleteness *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::TextureCompleteness *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__TextureCompleteness,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLTextureCompleteness" "', argument " "1"" of type '" "GLPipe::TextureCompleteness const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLTextureCompleteness" "', argument " "1"" of type '" "GLPipe::TextureCompleteness const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::TextureCompleteness * >(argp1);
  result = (GLPipe::TextureCompleteness *)new GLPipe::TextureCompleteness((GLPipe::TextureCompleteness const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__TextureCompleteness, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLTextureCompleteness(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLTextureCompleteness",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLTextureCompleteness__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLTextureCompleteness__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLTextureCompleteness'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::TextureCompleteness::TextureCompleteness()\n"
    "    GLPipe::TextureCompleteness::TextureCompleteness(GLPipe::TextureCompleteness const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLTextureCompleteness___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::TextureCompleteness *arg1 = (GLPipe::TextureCompleteness *) 0 ;
  GLPipe::TextureCompleteness *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__TextureCompleteness, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLTextureCompleteness___eq__" "', argument " "1"" of type '" "GLPipe::TextureCompleteness const *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::TextureCompleteness * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_GLPipe__TextureCompleteness,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLTextureCompleteness___eq__" "', argument " "2"" of type '" "GLPipe::TextureCompleteness const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GLTextureCompleteness___eq__" "', argument " "2"" of type '" "GLPipe::TextureCompleteness const &""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::TextureCompleteness * >(argp2);
  result = (bool)((GLPipe::TextureCompleteness const *)arg1)->operator ==((GLPipe::TextureCompleteness const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLTextureCompleteness___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::TextureCompleteness *arg1 = (GLPipe::TextureCompleteness *) 0 ;
  GLPipe::TextureCompleteness *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__TextureCompleteness, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLTextureCompleteness___lt__" "', argument " "1"" of type '" "GLPipe::TextureCompleteness const *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::TextureCompleteness * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_GLPipe__TextureCompleteness,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLTextureCompleteness___lt__" "', argument " "2"" of type '" "GLPipe::TextureCompleteness const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GLTextureCompleteness___lt__" "', argument " "2"" of type '" "GLPipe::TextureCompleteness const &""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::TextureCompleteness * >(argp2);
  result = (bool)((GLPipe::TextureCompleteness const *)arg1)->operator <((GLPipe::TextureCompleteness const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLTextureCompleteness_descriptorByteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::TextureCompleteness *arg1 = (GLPipe::TextureCompleteness *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__TextureCompleteness, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLTextureCompleteness_descriptorByteOffset_set" "', argument " "1"" of type '" "GLPipe::TextureCompleteness *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::TextureCompleteness * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLTextureCompleteness_descriptorByteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->descriptorByteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLTextureCompleteness_descriptorByteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::TextureCompleteness *arg1 = (GLPipe::TextureCompleteness *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLTextureCompleteness_descriptorByteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__TextureCompleteness, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLTextureCompleteness_descriptorByteOffset_get" "', argument " "1"" of type '" "GLPipe::TextureCompleteness *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::TextureCompleteness * >(argp1);
  result = (uint64_t) ((arg1)->descriptorByteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLTextureCompleteness_completeStatus_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::TextureCompleteness *arg1 = (GLPipe::TextureCompleteness *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__TextureCompleteness, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLTextureCompleteness_completeStatus_set" "', argument " "1"" of type '" "GLPipe::TextureCompleteness *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::TextureCompleteness * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLTextureCompleteness_completeStatus_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->completeStatus = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLTextureCompleteness_completeStatus_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::TextureCompleteness *arg1 = (GLPipe::TextureCompleteness *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLTextureCompleteness_completeStatus_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__TextureCompleteness, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLTextureCompleteness_completeStatus_get" "', argument " "1"" of type '" "GLPipe::TextureCompleteness *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::TextureCompleteness * >(argp1);
  result =  ((arg1)->completeStatus);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLTextureCompleteness_typeConflict_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::TextureCompleteness *arg1 = (GLPipe::TextureCompleteness *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__TextureCompleteness, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLTextureCompleteness_typeConflict_set" "', argument " "1"" of type '" "GLPipe::TextureCompleteness *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::TextureCompleteness * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLTextureCompleteness_typeConflict_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->typeConflict = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLTextureCompleteness_typeConflict_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::TextureCompleteness *arg1 = (GLPipe::TextureCompleteness *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLTextureCompleteness_typeConflict_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__TextureCompleteness, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLTextureCompleteness_typeConflict_get" "', argument " "1"" of type '" "GLPipe::TextureCompleteness *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::TextureCompleteness * >(argp1);
  result =  ((arg1)->typeConflict);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLTextureCompleteness(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::TextureCompleteness *arg1 = (GLPipe::TextureCompleteness *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLTextureCompleteness",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__TextureCompleteness, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLTextureCompleteness" "', argument " "1"" of type '" "GLPipe::TextureCompleteness *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::TextureCompleteness * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLTextureCompleteness) /* defines _wrap_delete_GLTextureCompleteness_destructor_closure */

SWIGINTERN int _wrap_new_GLFeedback__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::Feedback *)new GLPipe::Feedback();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Feedback, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLFeedback__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::Feedback *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__Feedback,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLFeedback" "', argument " "1"" of type '" "GLPipe::Feedback const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLFeedback" "', argument " "1"" of type '" "GLPipe::Feedback const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  result = (GLPipe::Feedback *)new GLPipe::Feedback((GLPipe::Feedback const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Feedback, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLFeedback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLFeedback",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLFeedback__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLFeedback__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLFeedback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::Feedback::Feedback()\n"
    "    GLPipe::Feedback::Feedback(GLPipe::Feedback const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLFeedback_feedbackResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = (GLPipe::Feedback *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFeedback_feedbackResourceId_set" "', argument " "1"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLFeedback_feedbackResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->feedbackResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFeedback_feedbackResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = (GLPipe::Feedback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFeedback_feedbackResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFeedback_feedbackResourceId_get" "', argument " "1"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  result = (ResourceId *)& ((arg1)->feedbackResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFeedback_bufferResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = (GLPipe::Feedback *) 0 ;
  rdcfixedarray< ResourceId,4 > *arg2 = (rdcfixedarray< ResourceId,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFeedback_bufferResourceId_set" "', argument " "1"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLFeedback_bufferResourceId_set' argument 2 of type 'rdcfixedarray< ResourceId,4 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLFeedback_bufferResourceId_set' argument 2 of type 'rdcfixedarray< ResourceId,4 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->bufferResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFeedback_bufferResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = (GLPipe::Feedback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< ResourceId,4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFeedback_bufferResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFeedback_bufferResourceId_get" "', argument " "1"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  result = (rdcfixedarray< ResourceId,4 > *)& ((arg1)->bufferResourceId);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFeedback_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = (GLPipe::Feedback *) 0 ;
  rdcfixedarray< uint64_t,4 > *arg2 = (rdcfixedarray< uint64_t,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFeedback_byteOffset_set" "', argument " "1"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLFeedback_byteOffset_set' argument 2 of type 'rdcfixedarray< uint64_t,4 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLFeedback_byteOffset_set' argument 2 of type 'rdcfixedarray< uint64_t,4 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->byteOffset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFeedback_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = (GLPipe::Feedback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint64_t,4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFeedback_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFeedback_byteOffset_get" "', argument " "1"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  result = (rdcfixedarray< uint64_t,4 > *)& ((arg1)->byteOffset);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFeedback_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = (GLPipe::Feedback *) 0 ;
  rdcfixedarray< uint64_t,4 > *arg2 = (rdcfixedarray< uint64_t,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFeedback_byteSize_set" "', argument " "1"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLFeedback_byteSize_set' argument 2 of type 'rdcfixedarray< uint64_t,4 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLFeedback_byteSize_set' argument 2 of type 'rdcfixedarray< uint64_t,4 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->byteSize = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFeedback_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = (GLPipe::Feedback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint64_t,4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFeedback_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFeedback_byteSize_get" "', argument " "1"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  result = (rdcfixedarray< uint64_t,4 > *)& ((arg1)->byteSize);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFeedback_active_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = (GLPipe::Feedback *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFeedback_active_set" "', argument " "1"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLFeedback_active_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->active = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFeedback_active_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = (GLPipe::Feedback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFeedback_active_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFeedback_active_get" "', argument " "1"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  result = (bool) ((arg1)->active);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFeedback_paused_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = (GLPipe::Feedback *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFeedback_paused_set" "', argument " "1"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLFeedback_paused_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->paused = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFeedback_paused_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = (GLPipe::Feedback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFeedback_paused_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFeedback_paused_get" "', argument " "1"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  result = (bool) ((arg1)->paused);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLFeedback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Feedback *arg1 = (GLPipe::Feedback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLFeedback",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Feedback, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLFeedback" "', argument " "1"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Feedback * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLFeedback) /* defines _wrap_delete_GLFeedback_destructor_closure */

SWIGINTERN int _wrap_new_GLRasterizerState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::RasterizerState *)new GLPipe::RasterizerState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__RasterizerState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLRasterizerState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::RasterizerState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__RasterizerState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLRasterizerState" "', argument " "1"" of type '" "GLPipe::RasterizerState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLRasterizerState" "', argument " "1"" of type '" "GLPipe::RasterizerState const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (GLPipe::RasterizerState *)new GLPipe::RasterizerState((GLPipe::RasterizerState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__RasterizerState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLRasterizerState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLRasterizerState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLRasterizerState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLRasterizerState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLRasterizerState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::RasterizerState::RasterizerState()\n"
    "    GLPipe::RasterizerState::RasterizerState(GLPipe::RasterizerState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_fillMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  FillMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_fillMode_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_fillMode_set" "', argument " "2"" of type '" "FillMode""'");
  } 
  arg2 = static_cast< FillMode >(val2);
  if (arg1) (arg1)->fillMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_fillMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FillMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_fillMode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_fillMode_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (FillMode) ((arg1)->fillMode);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_FillMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_cullMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  CullMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_cullMode_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_cullMode_set" "', argument " "2"" of type '" "CullMode""'");
  } 
  arg2 = static_cast< CullMode >(val2);
  if (arg1) (arg1)->cullMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_cullMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CullMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_cullMode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_cullMode_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (CullMode) ((arg1)->cullMode);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CullMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_frontCCW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_frontCCW_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_frontCCW_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->frontCCW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_frontCCW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_frontCCW_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_frontCCW_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->frontCCW);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_depthBias_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_depthBias_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_depthBias_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->depthBias = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_depthBias_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_depthBias_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_depthBias_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (float) ((arg1)->depthBias);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_slopeScaledDepthBias_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_slopeScaledDepthBias_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_slopeScaledDepthBias_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->slopeScaledDepthBias = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_slopeScaledDepthBias_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_slopeScaledDepthBias_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_slopeScaledDepthBias_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (float) ((arg1)->slopeScaledDepthBias);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_offsetClamp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_offsetClamp_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_offsetClamp_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->offsetClamp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_offsetClamp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_offsetClamp_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_offsetClamp_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (float) ((arg1)->offsetClamp);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_depthClamp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_depthClamp_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_depthClamp_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthClamp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_depthClamp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_depthClamp_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_depthClamp_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->depthClamp);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_multisampleEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_multisampleEnable_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_multisampleEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->multisampleEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_multisampleEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_multisampleEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_multisampleEnable_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->multisampleEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_sampleShading_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_sampleShading_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_sampleShading_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->sampleShading = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_sampleShading_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_sampleShading_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_sampleShading_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->sampleShading);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_sampleMask_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_sampleMask_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_sampleMask_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->sampleMask = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_sampleMask_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_sampleMask_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_sampleMask_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->sampleMask);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_sampleMaskValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_sampleMaskValue_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_sampleMaskValue_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sampleMaskValue = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_sampleMaskValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_sampleMaskValue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_sampleMaskValue_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (uint32_t) ((arg1)->sampleMaskValue);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_sampleCoverage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_sampleCoverage_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_sampleCoverage_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->sampleCoverage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_sampleCoverage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_sampleCoverage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_sampleCoverage_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->sampleCoverage);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_sampleCoverageInvert_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_sampleCoverageInvert_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_sampleCoverageInvert_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->sampleCoverageInvert = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_sampleCoverageInvert_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_sampleCoverageInvert_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_sampleCoverageInvert_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->sampleCoverageInvert);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_sampleCoverageValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_sampleCoverageValue_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_sampleCoverageValue_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->sampleCoverageValue = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_sampleCoverageValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_sampleCoverageValue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_sampleCoverageValue_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (float) ((arg1)->sampleCoverageValue);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_alphaToCoverage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_alphaToCoverage_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_alphaToCoverage_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->alphaToCoverage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_alphaToCoverage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_alphaToCoverage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_alphaToCoverage_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->alphaToCoverage);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_alphaToOne_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_alphaToOne_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_alphaToOne_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->alphaToOne = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_alphaToOne_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_alphaToOne_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_alphaToOne_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->alphaToOne);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_minSampleShadingRate_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_minSampleShadingRate_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_minSampleShadingRate_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->minSampleShadingRate = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_minSampleShadingRate_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_minSampleShadingRate_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_minSampleShadingRate_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (float) ((arg1)->minSampleShadingRate);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_programmablePointSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_programmablePointSize_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_programmablePointSize_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->programmablePointSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_programmablePointSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_programmablePointSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_programmablePointSize_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->programmablePointSize);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_pointSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_pointSize_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_pointSize_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->pointSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_pointSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_pointSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_pointSize_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (float) ((arg1)->pointSize);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_lineWidth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_lineWidth_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_lineWidth_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->lineWidth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_lineWidth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_lineWidth_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_lineWidth_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (float) ((arg1)->lineWidth);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_pointFadeThreshold_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_pointFadeThreshold_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_pointFadeThreshold_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->pointFadeThreshold = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_pointFadeThreshold_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_pointFadeThreshold_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_pointFadeThreshold_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (float) ((arg1)->pointFadeThreshold);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_pointOriginUpperLeft_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_pointOriginUpperLeft_set" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLRasterizerState_pointOriginUpperLeft_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->pointOriginUpperLeft = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizerState_pointOriginUpperLeft_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizerState_pointOriginUpperLeft_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizerState_pointOriginUpperLeft_get" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  result = (bool) ((arg1)->pointOriginUpperLeft);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLRasterizerState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::RasterizerState *arg1 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLRasterizerState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__RasterizerState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLRasterizerState" "', argument " "1"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::RasterizerState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLRasterizerState) /* defines _wrap_delete_GLRasterizerState_destructor_closure */

SWIGINTERN int _wrap_new_GLRasterizer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::Rasterizer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::Rasterizer *)new GLPipe::Rasterizer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Rasterizer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLRasterizer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::Rasterizer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::Rasterizer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__Rasterizer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLRasterizer" "', argument " "1"" of type '" "GLPipe::Rasterizer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLRasterizer" "', argument " "1"" of type '" "GLPipe::Rasterizer const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Rasterizer * >(argp1);
  result = (GLPipe::Rasterizer *)new GLPipe::Rasterizer((GLPipe::Rasterizer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Rasterizer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLRasterizer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLRasterizer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLRasterizer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLRasterizer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLRasterizer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::Rasterizer::Rasterizer()\n"
    "    GLPipe::Rasterizer::Rasterizer(GLPipe::Rasterizer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLRasterizer_viewports_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Rasterizer *arg1 = (GLPipe::Rasterizer *) 0 ;
  rdcarray< Viewport > *arg2 = (rdcarray< Viewport > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizer_viewports_set" "', argument " "1"" of type '" "GLPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Rasterizer * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLRasterizer_viewports_set' argument 2 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLRasterizer_viewports_set' argument 2 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->viewports = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizer_viewports_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Rasterizer *arg1 = (GLPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< Viewport > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizer_viewports_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizer_viewports_get" "', argument " "1"" of type '" "GLPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Rasterizer * >(argp1);
  result = (rdcarray< Viewport > *)& ((arg1)->viewports);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_Viewport_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizer_scissors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Rasterizer *arg1 = (GLPipe::Rasterizer *) 0 ;
  rdcarray< Scissor > *arg2 = (rdcarray< Scissor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizer_scissors_set" "', argument " "1"" of type '" "GLPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Rasterizer * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLRasterizer_scissors_set' argument 2 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLRasterizer_scissors_set' argument 2 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->scissors = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizer_scissors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Rasterizer *arg1 = (GLPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< Scissor > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizer_scissors_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizer_scissors_get" "', argument " "1"" of type '" "GLPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Rasterizer * >(argp1);
  result = (rdcarray< Scissor > *)& ((arg1)->scissors);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_Scissor_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizer_state_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Rasterizer *arg1 = (GLPipe::Rasterizer *) 0 ;
  GLPipe::RasterizerState *arg2 = (GLPipe::RasterizerState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizer_state_set" "', argument " "1"" of type '" "GLPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Rasterizer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLRasterizer_state_set" "', argument " "2"" of type '" "GLPipe::RasterizerState *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::RasterizerState * >(argp2);
  if (arg1) (arg1)->state = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLRasterizer_state_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Rasterizer *arg1 = (GLPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::RasterizerState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLRasterizer_state_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLRasterizer_state_get" "', argument " "1"" of type '" "GLPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Rasterizer * >(argp1);
  result = (GLPipe::RasterizerState *)& ((arg1)->state);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__RasterizerState, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLRasterizer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Rasterizer *arg1 = (GLPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLRasterizer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Rasterizer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLRasterizer" "', argument " "1"" of type '" "GLPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Rasterizer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLRasterizer) /* defines _wrap_delete_GLRasterizer_destructor_closure */

SWIGINTERN int _wrap_new_GLDepthState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::DepthState *)new GLPipe::DepthState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__DepthState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLDepthState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::DepthState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__DepthState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLDepthState" "', argument " "1"" of type '" "GLPipe::DepthState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLDepthState" "', argument " "1"" of type '" "GLPipe::DepthState const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  result = (GLPipe::DepthState *)new GLPipe::DepthState((GLPipe::DepthState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__DepthState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLDepthState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLDepthState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLDepthState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLDepthState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLDepthState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::DepthState::DepthState()\n"
    "    GLPipe::DepthState::DepthState(GLPipe::DepthState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLDepthState_depthEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = (GLPipe::DepthState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLDepthState_depthEnable_set" "', argument " "1"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLDepthState_depthEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLDepthState_depthEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = (GLPipe::DepthState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLDepthState_depthEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLDepthState_depthEnable_get" "', argument " "1"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  result = (bool) ((arg1)->depthEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLDepthState_depthFunction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = (GLPipe::DepthState *) 0 ;
  CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLDepthState_depthFunction_set" "', argument " "1"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLDepthState_depthFunction_set" "', argument " "2"" of type '" "CompareFunction""'");
  } 
  arg2 = static_cast< CompareFunction >(val2);
  if (arg1) (arg1)->depthFunction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLDepthState_depthFunction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = (GLPipe::DepthState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompareFunction result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLDepthState_depthFunction_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLDepthState_depthFunction_get" "', argument " "1"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  result = (CompareFunction) ((arg1)->depthFunction);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CompareFunction->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLDepthState_depthWrites_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = (GLPipe::DepthState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLDepthState_depthWrites_set" "', argument " "1"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLDepthState_depthWrites_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthWrites = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLDepthState_depthWrites_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = (GLPipe::DepthState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLDepthState_depthWrites_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLDepthState_depthWrites_get" "', argument " "1"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  result = (bool) ((arg1)->depthWrites);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLDepthState_depthBounds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = (GLPipe::DepthState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLDepthState_depthBounds_set" "', argument " "1"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLDepthState_depthBounds_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthBounds = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLDepthState_depthBounds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = (GLPipe::DepthState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLDepthState_depthBounds_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLDepthState_depthBounds_get" "', argument " "1"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  result = (bool) ((arg1)->depthBounds);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLDepthState_nearBound_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = (GLPipe::DepthState *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLDepthState_nearBound_set" "', argument " "1"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLDepthState_nearBound_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->nearBound = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLDepthState_nearBound_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = (GLPipe::DepthState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLDepthState_nearBound_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLDepthState_nearBound_get" "', argument " "1"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  result = (double) ((arg1)->nearBound);
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLDepthState_farBound_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = (GLPipe::DepthState *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLDepthState_farBound_set" "', argument " "1"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLDepthState_farBound_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->farBound = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLDepthState_farBound_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = (GLPipe::DepthState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLDepthState_farBound_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLDepthState_farBound_get" "', argument " "1"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  result = (double) ((arg1)->farBound);
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLDepthState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::DepthState *arg1 = (GLPipe::DepthState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLDepthState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__DepthState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLDepthState" "', argument " "1"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::DepthState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLDepthState) /* defines _wrap_delete_GLDepthState_destructor_closure */

SWIGINTERN int _wrap_new_GLStencilState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::StencilState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::StencilState *)new GLPipe::StencilState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__StencilState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLStencilState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::StencilState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::StencilState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__StencilState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLStencilState" "', argument " "1"" of type '" "GLPipe::StencilState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLStencilState" "', argument " "1"" of type '" "GLPipe::StencilState const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::StencilState * >(argp1);
  result = (GLPipe::StencilState *)new GLPipe::StencilState((GLPipe::StencilState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__StencilState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLStencilState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLStencilState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLStencilState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLStencilState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLStencilState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::StencilState::StencilState()\n"
    "    GLPipe::StencilState::StencilState(GLPipe::StencilState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLStencilState_stencilEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::StencilState *arg1 = (GLPipe::StencilState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__StencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLStencilState_stencilEnable_set" "', argument " "1"" of type '" "GLPipe::StencilState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::StencilState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLStencilState_stencilEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->stencilEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLStencilState_stencilEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::StencilState *arg1 = (GLPipe::StencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLStencilState_stencilEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__StencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLStencilState_stencilEnable_get" "', argument " "1"" of type '" "GLPipe::StencilState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::StencilState * >(argp1);
  result = (bool) ((arg1)->stencilEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLStencilState_frontFace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::StencilState *arg1 = (GLPipe::StencilState *) 0 ;
  StencilFace *arg2 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__StencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLStencilState_frontFace_set" "', argument " "1"" of type '" "GLPipe::StencilState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::StencilState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLStencilState_frontFace_set" "', argument " "2"" of type '" "StencilFace *""'"); 
  }
  arg2 = reinterpret_cast< StencilFace * >(argp2);
  if (arg1) (arg1)->frontFace = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLStencilState_frontFace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::StencilState *arg1 = (GLPipe::StencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StencilFace *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLStencilState_frontFace_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__StencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLStencilState_frontFace_get" "', argument " "1"" of type '" "GLPipe::StencilState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::StencilState * >(argp1);
  result = (StencilFace *)& ((arg1)->frontFace);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StencilFace, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLStencilState_backFace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::StencilState *arg1 = (GLPipe::StencilState *) 0 ;
  StencilFace *arg2 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__StencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLStencilState_backFace_set" "', argument " "1"" of type '" "GLPipe::StencilState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::StencilState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLStencilState_backFace_set" "', argument " "2"" of type '" "StencilFace *""'"); 
  }
  arg2 = reinterpret_cast< StencilFace * >(argp2);
  if (arg1) (arg1)->backFace = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLStencilState_backFace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::StencilState *arg1 = (GLPipe::StencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StencilFace *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLStencilState_backFace_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__StencilState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLStencilState_backFace_get" "', argument " "1"" of type '" "GLPipe::StencilState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::StencilState * >(argp1);
  result = (StencilFace *)& ((arg1)->backFace);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StencilFace, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLStencilState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::StencilState *arg1 = (GLPipe::StencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLStencilState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__StencilState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLStencilState" "', argument " "1"" of type '" "GLPipe::StencilState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::StencilState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLStencilState) /* defines _wrap_delete_GLStencilState_destructor_closure */

SWIGINTERN int _wrap_new_GLFBO__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::FBO *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::FBO *)new GLPipe::FBO();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__FBO, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLFBO__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::FBO *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__FBO,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLFBO" "', argument " "1"" of type '" "GLPipe::FBO const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLFBO" "', argument " "1"" of type '" "GLPipe::FBO const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  result = (GLPipe::FBO *)new GLPipe::FBO((GLPipe::FBO const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__FBO, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLFBO(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLFBO",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLFBO__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLFBO__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLFBO'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::FBO::FBO()\n"
    "    GLPipe::FBO::FBO(GLPipe::FBO const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLFBO_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = (GLPipe::FBO *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFBO_resourceId_set" "', argument " "1"" of type '" "GLPipe::FBO *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLFBO_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFBO_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = (GLPipe::FBO *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFBO_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFBO_resourceId_get" "', argument " "1"" of type '" "GLPipe::FBO *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFBO_colorAttachments_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = (GLPipe::FBO *) 0 ;
  rdcarray< Descriptor > *arg2 = (rdcarray< Descriptor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFBO_colorAttachments_set" "', argument " "1"" of type '" "GLPipe::FBO *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLFBO_colorAttachments_set' argument 2 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLFBO_colorAttachments_set' argument 2 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->colorAttachments = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFBO_colorAttachments_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = (GLPipe::FBO *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< Descriptor > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFBO_colorAttachments_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFBO_colorAttachments_get" "', argument " "1"" of type '" "GLPipe::FBO *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  result = (rdcarray< Descriptor > *)& ((arg1)->colorAttachments);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_Descriptor_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFBO_depthAttachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = (GLPipe::FBO *) 0 ;
  Descriptor *arg2 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFBO_depthAttachment_set" "', argument " "1"" of type '" "GLPipe::FBO *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLFBO_depthAttachment_set" "', argument " "2"" of type '" "Descriptor *""'"); 
  }
  arg2 = reinterpret_cast< Descriptor * >(argp2);
  if (arg1) (arg1)->depthAttachment = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFBO_depthAttachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = (GLPipe::FBO *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Descriptor *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFBO_depthAttachment_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFBO_depthAttachment_get" "', argument " "1"" of type '" "GLPipe::FBO *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  result = (Descriptor *)& ((arg1)->depthAttachment);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Descriptor, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFBO_stencilAttachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = (GLPipe::FBO *) 0 ;
  Descriptor *arg2 = (Descriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFBO_stencilAttachment_set" "', argument " "1"" of type '" "GLPipe::FBO *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_Descriptor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLFBO_stencilAttachment_set" "', argument " "2"" of type '" "Descriptor *""'"); 
  }
  arg2 = reinterpret_cast< Descriptor * >(argp2);
  if (arg1) (arg1)->stencilAttachment = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFBO_stencilAttachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = (GLPipe::FBO *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Descriptor *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFBO_stencilAttachment_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFBO_stencilAttachment_get" "', argument " "1"" of type '" "GLPipe::FBO *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  result = (Descriptor *)& ((arg1)->stencilAttachment);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Descriptor, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFBO_drawBuffers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = (GLPipe::FBO *) 0 ;
  rdcarray< int32_t > *arg2 = (rdcarray< int32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFBO_drawBuffers_set" "', argument " "1"" of type '" "GLPipe::FBO *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< int32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLFBO_drawBuffers_set' argument 2 of type 'rdcarray< int32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLFBO_drawBuffers_set' argument 2 of type 'rdcarray< int32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->drawBuffers = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFBO_drawBuffers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = (GLPipe::FBO *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< int32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFBO_drawBuffers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFBO_drawBuffers_get" "', argument " "1"" of type '" "GLPipe::FBO *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  result = (rdcarray< int32_t > *)& ((arg1)->drawBuffers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFBO_readBuffer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = (GLPipe::FBO *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFBO_readBuffer_set" "', argument " "1"" of type '" "GLPipe::FBO *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLFBO_readBuffer_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->readBuffer = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFBO_readBuffer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = (GLPipe::FBO *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFBO_readBuffer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFBO_readBuffer_get" "', argument " "1"" of type '" "GLPipe::FBO *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  result = (int32_t) ((arg1)->readBuffer);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLFBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FBO *arg1 = (GLPipe::FBO *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLFBO",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FBO, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLFBO" "', argument " "1"" of type '" "GLPipe::FBO *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FBO * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLFBO) /* defines _wrap_delete_GLFBO_destructor_closure */

SWIGINTERN int _wrap_new_GLBlendState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::BlendState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::BlendState *)new GLPipe::BlendState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__BlendState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLBlendState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::BlendState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::BlendState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__BlendState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLBlendState" "', argument " "1"" of type '" "GLPipe::BlendState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLBlendState" "', argument " "1"" of type '" "GLPipe::BlendState const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::BlendState * >(argp1);
  result = (GLPipe::BlendState *)new GLPipe::BlendState((GLPipe::BlendState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__BlendState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLBlendState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLBlendState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLBlendState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLBlendState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLBlendState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::BlendState::BlendState()\n"
    "    GLPipe::BlendState::BlendState(GLPipe::BlendState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLBlendState_blends_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::BlendState *arg1 = (GLPipe::BlendState *) 0 ;
  rdcarray< ColorBlend > *arg2 = (rdcarray< ColorBlend > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLBlendState_blends_set" "', argument " "1"" of type '" "GLPipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::BlendState * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLBlendState_blends_set' argument 2 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLBlendState_blends_set' argument 2 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->blends = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLBlendState_blends_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::BlendState *arg1 = (GLPipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ColorBlend > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLBlendState_blends_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLBlendState_blends_get" "', argument " "1"" of type '" "GLPipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::BlendState * >(argp1);
  result = (rdcarray< ColorBlend > *)& ((arg1)->blends);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ColorBlend_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLBlendState_blendFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::BlendState *arg1 = (GLPipe::BlendState *) 0 ;
  rdcfixedarray< float,4 > *arg2 = (rdcfixedarray< float,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLBlendState_blendFactor_set" "', argument " "1"" of type '" "GLPipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::BlendState * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLBlendState_blendFactor_set' argument 2 of type 'rdcfixedarray< float,4 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLBlendState_blendFactor_set' argument 2 of type 'rdcfixedarray< float,4 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->blendFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLBlendState_blendFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::BlendState *arg1 = (GLPipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< float,4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLBlendState_blendFactor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLBlendState_blendFactor_get" "', argument " "1"" of type '" "GLPipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::BlendState * >(argp1);
  result = (rdcfixedarray< float,4 > *)& ((arg1)->blendFactor);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLBlendState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::BlendState *arg1 = (GLPipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLBlendState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__BlendState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLBlendState" "', argument " "1"" of type '" "GLPipe::BlendState *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::BlendState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLBlendState) /* defines _wrap_delete_GLBlendState_destructor_closure */

SWIGINTERN int _wrap_new_GLFrameBuffer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::FrameBuffer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::FrameBuffer *)new GLPipe::FrameBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__FrameBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLFrameBuffer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::FrameBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::FrameBuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__FrameBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLFrameBuffer" "', argument " "1"" of type '" "GLPipe::FrameBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLFrameBuffer" "', argument " "1"" of type '" "GLPipe::FrameBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FrameBuffer * >(argp1);
  result = (GLPipe::FrameBuffer *)new GLPipe::FrameBuffer((GLPipe::FrameBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__FrameBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLFrameBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLFrameBuffer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLFrameBuffer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLFrameBuffer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLFrameBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::FrameBuffer::FrameBuffer()\n"
    "    GLPipe::FrameBuffer::FrameBuffer(GLPipe::FrameBuffer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLFrameBuffer_framebufferSRGB_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FrameBuffer *arg1 = (GLPipe::FrameBuffer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FrameBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFrameBuffer_framebufferSRGB_set" "', argument " "1"" of type '" "GLPipe::FrameBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FrameBuffer * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLFrameBuffer_framebufferSRGB_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->framebufferSRGB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFrameBuffer_framebufferSRGB_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FrameBuffer *arg1 = (GLPipe::FrameBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFrameBuffer_framebufferSRGB_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FrameBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFrameBuffer_framebufferSRGB_get" "', argument " "1"" of type '" "GLPipe::FrameBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FrameBuffer * >(argp1);
  result = (bool) ((arg1)->framebufferSRGB);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFrameBuffer_dither_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FrameBuffer *arg1 = (GLPipe::FrameBuffer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FrameBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFrameBuffer_dither_set" "', argument " "1"" of type '" "GLPipe::FrameBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FrameBuffer * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLFrameBuffer_dither_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->dither = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFrameBuffer_dither_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FrameBuffer *arg1 = (GLPipe::FrameBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFrameBuffer_dither_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FrameBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFrameBuffer_dither_get" "', argument " "1"" of type '" "GLPipe::FrameBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FrameBuffer * >(argp1);
  result = (bool) ((arg1)->dither);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFrameBuffer_drawFBO_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FrameBuffer *arg1 = (GLPipe::FrameBuffer *) 0 ;
  GLPipe::FBO *arg2 = (GLPipe::FBO *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FrameBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFrameBuffer_drawFBO_set" "', argument " "1"" of type '" "GLPipe::FrameBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FrameBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLFrameBuffer_drawFBO_set" "', argument " "2"" of type '" "GLPipe::FBO *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::FBO * >(argp2);
  if (arg1) (arg1)->drawFBO = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFrameBuffer_drawFBO_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FrameBuffer *arg1 = (GLPipe::FrameBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::FBO *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFrameBuffer_drawFBO_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FrameBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFrameBuffer_drawFBO_get" "', argument " "1"" of type '" "GLPipe::FrameBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FrameBuffer * >(argp1);
  result = (GLPipe::FBO *)& ((arg1)->drawFBO);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFrameBuffer_readFBO_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FrameBuffer *arg1 = (GLPipe::FrameBuffer *) 0 ;
  GLPipe::FBO *arg2 = (GLPipe::FBO *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FrameBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFrameBuffer_readFBO_set" "', argument " "1"" of type '" "GLPipe::FrameBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FrameBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLFrameBuffer_readFBO_set" "', argument " "2"" of type '" "GLPipe::FBO *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::FBO * >(argp2);
  if (arg1) (arg1)->readFBO = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFrameBuffer_readFBO_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FrameBuffer *arg1 = (GLPipe::FrameBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::FBO *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFrameBuffer_readFBO_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FrameBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFrameBuffer_readFBO_get" "', argument " "1"" of type '" "GLPipe::FrameBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FrameBuffer * >(argp1);
  result = (GLPipe::FBO *)& ((arg1)->readFBO);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__FBO, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFrameBuffer_blendState_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FrameBuffer *arg1 = (GLPipe::FrameBuffer *) 0 ;
  GLPipe::BlendState *arg2 = (GLPipe::BlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FrameBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFrameBuffer_blendState_set" "', argument " "1"" of type '" "GLPipe::FrameBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FrameBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__BlendState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLFrameBuffer_blendState_set" "', argument " "2"" of type '" "GLPipe::BlendState *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::BlendState * >(argp2);
  if (arg1) (arg1)->blendState = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLFrameBuffer_blendState_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FrameBuffer *arg1 = (GLPipe::FrameBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::BlendState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLFrameBuffer_blendState_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FrameBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLFrameBuffer_blendState_get" "', argument " "1"" of type '" "GLPipe::FrameBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FrameBuffer * >(argp1);
  result = (GLPipe::BlendState *)& ((arg1)->blendState);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__BlendState, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLFrameBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::FrameBuffer *arg1 = (GLPipe::FrameBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLFrameBuffer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__FrameBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLFrameBuffer" "', argument " "1"" of type '" "GLPipe::FrameBuffer *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::FrameBuffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLFrameBuffer) /* defines _wrap_delete_GLFrameBuffer_destructor_closure */

SWIGINTERN int _wrap_new_GLHints__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GLPipe::Hints *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (GLPipe::Hints *)new GLPipe::Hints();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Hints, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLHints__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLPipe::Hints *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_GLPipe__Hints,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GLHints" "', argument " "1"" of type '" "GLPipe::Hints const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GLHints" "', argument " "1"" of type '" "GLPipe::Hints const &""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  result = (GLPipe::Hints *)new GLPipe::Hints((GLPipe::Hints const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Hints, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_GLHints(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_GLHints",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GLHints__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_GLHints__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GLHints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GLPipe::Hints::Hints()\n"
    "    GLPipe::Hints::Hints(GLPipe::Hints const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_GLHints_derivatives_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = (GLPipe::Hints *) 0 ;
  QualityHint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLHints_derivatives_set" "', argument " "1"" of type '" "GLPipe::Hints *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLHints_derivatives_set" "', argument " "2"" of type '" "QualityHint""'");
  } 
  arg2 = static_cast< QualityHint >(val2);
  if (arg1) (arg1)->derivatives = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLHints_derivatives_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = (GLPipe::Hints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  QualityHint result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLHints_derivatives_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLHints_derivatives_get" "', argument " "1"" of type '" "GLPipe::Hints *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  result = (QualityHint) ((arg1)->derivatives);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_QualityHint->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLHints_lineSmoothing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = (GLPipe::Hints *) 0 ;
  QualityHint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLHints_lineSmoothing_set" "', argument " "1"" of type '" "GLPipe::Hints *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLHints_lineSmoothing_set" "', argument " "2"" of type '" "QualityHint""'");
  } 
  arg2 = static_cast< QualityHint >(val2);
  if (arg1) (arg1)->lineSmoothing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLHints_lineSmoothing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = (GLPipe::Hints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  QualityHint result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLHints_lineSmoothing_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLHints_lineSmoothing_get" "', argument " "1"" of type '" "GLPipe::Hints *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  result = (QualityHint) ((arg1)->lineSmoothing);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_QualityHint->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLHints_polySmoothing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = (GLPipe::Hints *) 0 ;
  QualityHint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLHints_polySmoothing_set" "', argument " "1"" of type '" "GLPipe::Hints *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLHints_polySmoothing_set" "', argument " "2"" of type '" "QualityHint""'");
  } 
  arg2 = static_cast< QualityHint >(val2);
  if (arg1) (arg1)->polySmoothing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLHints_polySmoothing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = (GLPipe::Hints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  QualityHint result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLHints_polySmoothing_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLHints_polySmoothing_get" "', argument " "1"" of type '" "GLPipe::Hints *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  result = (QualityHint) ((arg1)->polySmoothing);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_QualityHint->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLHints_textureCompression_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = (GLPipe::Hints *) 0 ;
  QualityHint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLHints_textureCompression_set" "', argument " "1"" of type '" "GLPipe::Hints *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLHints_textureCompression_set" "', argument " "2"" of type '" "QualityHint""'");
  } 
  arg2 = static_cast< QualityHint >(val2);
  if (arg1) (arg1)->textureCompression = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLHints_textureCompression_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = (GLPipe::Hints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  QualityHint result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLHints_textureCompression_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLHints_textureCompression_get" "', argument " "1"" of type '" "GLPipe::Hints *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  result = (QualityHint) ((arg1)->textureCompression);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_QualityHint->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLHints_lineSmoothingEnabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = (GLPipe::Hints *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLHints_lineSmoothingEnabled_set" "', argument " "1"" of type '" "GLPipe::Hints *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLHints_lineSmoothingEnabled_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->lineSmoothingEnabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLHints_lineSmoothingEnabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = (GLPipe::Hints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLHints_lineSmoothingEnabled_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLHints_lineSmoothingEnabled_get" "', argument " "1"" of type '" "GLPipe::Hints *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  result = (bool) ((arg1)->lineSmoothingEnabled);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLHints_polySmoothingEnabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = (GLPipe::Hints *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLHints_polySmoothingEnabled_set" "', argument " "1"" of type '" "GLPipe::Hints *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLHints_polySmoothingEnabled_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->polySmoothingEnabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLHints_polySmoothingEnabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = (GLPipe::Hints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLHints_polySmoothingEnabled_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLHints_polySmoothingEnabled_get" "', argument " "1"" of type '" "GLPipe::Hints *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  result = (bool) ((arg1)->polySmoothingEnabled);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLHints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::Hints *arg1 = (GLPipe::Hints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLHints",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__Hints, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLHints" "', argument " "1"" of type '" "GLPipe::Hints *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::Hints * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLHints) /* defines _wrap_delete_GLHints_destructor_closure */

SWIGINTERN PyObject *_wrap_GLState_vertexInput_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::VertexInput *arg2 = (GLPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_vertexInput_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_vertexInput_set" "', argument " "2"" of type '" "GLPipe::VertexInput *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::VertexInput * >(argp2);
  if (arg1) (arg1)->vertexInput = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_vertexInput_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::VertexInput *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_vertexInput_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_vertexInput_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::VertexInput *)& ((arg1)->vertexInput);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__VertexInput, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_vertexShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::Shader *arg2 = (GLPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_vertexShader_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_vertexShader_set" "', argument " "2"" of type '" "GLPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::Shader * >(argp2);
  if (arg1) (arg1)->vertexShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_vertexShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_vertexShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_vertexShader_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::Shader *)& ((arg1)->vertexShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_tessControlShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::Shader *arg2 = (GLPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_tessControlShader_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_tessControlShader_set" "', argument " "2"" of type '" "GLPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::Shader * >(argp2);
  if (arg1) (arg1)->tessControlShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_tessControlShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_tessControlShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_tessControlShader_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::Shader *)& ((arg1)->tessControlShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_tessEvalShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::Shader *arg2 = (GLPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_tessEvalShader_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_tessEvalShader_set" "', argument " "2"" of type '" "GLPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::Shader * >(argp2);
  if (arg1) (arg1)->tessEvalShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_tessEvalShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_tessEvalShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_tessEvalShader_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::Shader *)& ((arg1)->tessEvalShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_geometryShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::Shader *arg2 = (GLPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_geometryShader_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_geometryShader_set" "', argument " "2"" of type '" "GLPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::Shader * >(argp2);
  if (arg1) (arg1)->geometryShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_geometryShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_geometryShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_geometryShader_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::Shader *)& ((arg1)->geometryShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_fragmentShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::Shader *arg2 = (GLPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_fragmentShader_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_fragmentShader_set" "', argument " "2"" of type '" "GLPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::Shader * >(argp2);
  if (arg1) (arg1)->fragmentShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_fragmentShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_fragmentShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_fragmentShader_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::Shader *)& ((arg1)->fragmentShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_computeShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::Shader *arg2 = (GLPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_computeShader_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_computeShader_set" "', argument " "2"" of type '" "GLPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::Shader * >(argp2);
  if (arg1) (arg1)->computeShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_computeShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_computeShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_computeShader_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::Shader *)& ((arg1)->computeShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_pipelineResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_pipelineResourceId_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_pipelineResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->pipelineResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_pipelineResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_pipelineResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_pipelineResourceId_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (ResourceId *)& ((arg1)->pipelineResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_vertexProcessing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::FixedVertexProcessing *arg2 = (GLPipe::FixedVertexProcessing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_vertexProcessing_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_vertexProcessing_set" "', argument " "2"" of type '" "GLPipe::FixedVertexProcessing *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::FixedVertexProcessing * >(argp2);
  if (arg1) (arg1)->vertexProcessing = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_vertexProcessing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::FixedVertexProcessing *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_vertexProcessing_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_vertexProcessing_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::FixedVertexProcessing *)& ((arg1)->vertexProcessing);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__FixedVertexProcessing, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_descriptorStore_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_descriptorStore_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_descriptorStore_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->descriptorStore = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_descriptorStore_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_descriptorStore_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_descriptorStore_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (ResourceId *)& ((arg1)->descriptorStore);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_descriptorCount_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_descriptorCount_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLState_descriptorCount_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->descriptorCount = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_descriptorCount_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_descriptorCount_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_descriptorCount_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (uint32_t) ((arg1)->descriptorCount);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_descriptorByteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_descriptorByteSize_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GLState_descriptorByteSize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->descriptorByteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_descriptorByteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_descriptorByteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_descriptorByteSize_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (uint32_t) ((arg1)->descriptorByteSize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_textureCompleteness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  rdcarray< GLPipe::TextureCompleteness > *arg2 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_textureCompleteness_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'GLState_textureCompleteness_set' argument 2 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'GLState_textureCompleteness_set' argument 2 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->textureCompleteness = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_textureCompleteness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< GLPipe::TextureCompleteness > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_textureCompleteness_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_textureCompleteness_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (rdcarray< GLPipe::TextureCompleteness > *)& ((arg1)->textureCompleteness);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_GLPipe__TextureCompleteness_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_transformFeedback_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::Feedback *arg2 = (GLPipe::Feedback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_transformFeedback_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_transformFeedback_set" "', argument " "2"" of type '" "GLPipe::Feedback *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::Feedback * >(argp2);
  if (arg1) (arg1)->transformFeedback = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_transformFeedback_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::Feedback *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_transformFeedback_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_transformFeedback_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::Feedback *)& ((arg1)->transformFeedback);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Feedback, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_rasterizer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::Rasterizer *arg2 = (GLPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_rasterizer_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_rasterizer_set" "', argument " "2"" of type '" "GLPipe::Rasterizer *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::Rasterizer * >(argp2);
  if (arg1) (arg1)->rasterizer = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_rasterizer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::Rasterizer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_rasterizer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_rasterizer_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::Rasterizer *)& ((arg1)->rasterizer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Rasterizer, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_depthState_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::DepthState *arg2 = (GLPipe::DepthState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_depthState_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_depthState_set" "', argument " "2"" of type '" "GLPipe::DepthState *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::DepthState * >(argp2);
  if (arg1) (arg1)->depthState = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_depthState_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::DepthState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_depthState_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_depthState_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::DepthState *)& ((arg1)->depthState);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__DepthState, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_stencilState_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::StencilState *arg2 = (GLPipe::StencilState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_stencilState_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__StencilState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_stencilState_set" "', argument " "2"" of type '" "GLPipe::StencilState *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::StencilState * >(argp2);
  if (arg1) (arg1)->stencilState = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_stencilState_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::StencilState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_stencilState_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_stencilState_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::StencilState *)& ((arg1)->stencilState);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__StencilState, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_framebuffer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::FrameBuffer *arg2 = (GLPipe::FrameBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_framebuffer_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__FrameBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_framebuffer_set" "', argument " "2"" of type '" "GLPipe::FrameBuffer *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::FrameBuffer * >(argp2);
  if (arg1) (arg1)->framebuffer = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_framebuffer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::FrameBuffer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_framebuffer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_framebuffer_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::FrameBuffer *)& ((arg1)->framebuffer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__FrameBuffer, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_hints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  GLPipe::Hints *arg2 = (GLPipe::Hints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_hints_set" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GLState_hints_set" "', argument " "2"" of type '" "GLPipe::Hints *""'"); 
  }
  arg2 = reinterpret_cast< GLPipe::Hints * >(argp2);
  if (arg1) (arg1)->hints = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLState_hints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GLPipe::Hints *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"GLState_hints_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLState_hints_get" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  result = (GLPipe::Hints *)& ((arg1)->hints);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GLPipe__Hints, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GLPipe::State *arg1 = (GLPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GLState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLPipe__State, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLState" "', argument " "1"" of type '" "GLPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< GLPipe::State * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GLState) /* defines _wrap_delete_GLState_destructor_closure */

SWIGINTERN int _wrap_new_SectionType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_SectionType",0,0,0)) SWIG_fail;
  result = (SectionType *)new SectionType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SectionType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_SectionType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionType *arg1 = (SectionType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_SectionType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SectionType" "', argument " "1"" of type '" "SectionType *""'"); 
  }
  arg1 = reinterpret_cast< SectionType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_SectionType) /* defines _wrap_delete_SectionType_destructor_closure */

SWIGINTERN int _wrap_new_DebugVariableType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugVariableType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_DebugVariableType",0,0,0)) SWIG_fail;
  result = (DebugVariableType *)new DebugVariableType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DebugVariableType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_DebugVariableType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugVariableType *arg1 = (DebugVariableType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DebugVariableType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugVariableType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DebugVariableType" "', argument " "1"" of type '" "DebugVariableType *""'"); 
  }
  arg1 = reinterpret_cast< DebugVariableType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DebugVariableType) /* defines _wrap_delete_DebugVariableType_destructor_closure */

SWIGINTERN int _wrap_new_VarType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VarType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_VarType",0,0,0)) SWIG_fail;
  result = (VarType *)new VarType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VarType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_VarType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VarType *arg1 = (VarType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VarType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VarType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VarType" "', argument " "1"" of type '" "VarType *""'"); 
  }
  arg1 = reinterpret_cast< VarType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VarType) /* defines _wrap_delete_VarType_destructor_closure */

SWIGINTERN PyObject *_wrap_VarTypeByteSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VarType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "VarTypeByteSize" "', argument " "1"" of type '" "VarType""'");
  } 
  arg1 = static_cast< VarType >(val1);
  result = (uint32_t)VarTypeByteSize(arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_CompType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CompType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_CompType",0,0,0)) SWIG_fail;
  result = (CompType *)new CompType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_CompType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CompType *arg1 = (CompType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_CompType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CompType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CompType" "', argument " "1"" of type '" "CompType *""'"); 
  }
  arg1 = reinterpret_cast< CompType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CompType) /* defines _wrap_delete_CompType_destructor_closure */

SWIGINTERN PyObject *_wrap_VarTypeCompType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VarType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  CompType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "VarTypeCompType" "', argument " "1"" of type '" "VarType""'");
  } 
  arg1 = static_cast< VarType >(val1);
  result = (CompType)VarTypeCompType(arg1);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CompType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_TextureSwizzle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSwizzle *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_TextureSwizzle",0,0,0)) SWIG_fail;
  result = (TextureSwizzle *)new TextureSwizzle();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureSwizzle, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_TextureSwizzle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureSwizzle *arg1 = (TextureSwizzle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TextureSwizzle",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureSwizzle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TextureSwizzle" "', argument " "1"" of type '" "TextureSwizzle *""'"); 
  }
  arg1 = reinterpret_cast< TextureSwizzle * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TextureSwizzle) /* defines _wrap_delete_TextureSwizzle_destructor_closure */

SWIGINTERN int _wrap_new_AddressMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AddressMode *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_AddressMode",0,0,0)) SWIG_fail;
  result = (AddressMode *)new AddressMode();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AddressMode, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_AddressMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AddressMode *arg1 = (AddressMode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_AddressMode",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_AddressMode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AddressMode" "', argument " "1"" of type '" "AddressMode *""'"); 
  }
  arg1 = reinterpret_cast< AddressMode * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_AddressMode) /* defines _wrap_delete_AddressMode_destructor_closure */

SWIGINTERN int _wrap_new_YcbcrConversion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YcbcrConversion *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_YcbcrConversion",0,0,0)) SWIG_fail;
  result = (YcbcrConversion *)new YcbcrConversion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_YcbcrConversion, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_YcbcrConversion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YcbcrConversion *arg1 = (YcbcrConversion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_YcbcrConversion",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_YcbcrConversion, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YcbcrConversion" "', argument " "1"" of type '" "YcbcrConversion *""'"); 
  }
  arg1 = reinterpret_cast< YcbcrConversion * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_YcbcrConversion) /* defines _wrap_delete_YcbcrConversion_destructor_closure */

SWIGINTERN int _wrap_new_YcbcrRange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YcbcrRange *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_YcbcrRange",0,0,0)) SWIG_fail;
  result = (YcbcrRange *)new YcbcrRange();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_YcbcrRange, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_YcbcrRange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YcbcrRange *arg1 = (YcbcrRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_YcbcrRange",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_YcbcrRange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YcbcrRange" "', argument " "1"" of type '" "YcbcrRange *""'"); 
  }
  arg1 = reinterpret_cast< YcbcrRange * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_YcbcrRange) /* defines _wrap_delete_YcbcrRange_destructor_closure */

SWIGINTERN int _wrap_new_ChromaSampleLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ChromaSampleLocation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ChromaSampleLocation",0,0,0)) SWIG_fail;
  result = (ChromaSampleLocation *)new ChromaSampleLocation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChromaSampleLocation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ChromaSampleLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ChromaSampleLocation *arg1 = (ChromaSampleLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ChromaSampleLocation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ChromaSampleLocation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChromaSampleLocation" "', argument " "1"" of type '" "ChromaSampleLocation *""'"); 
  }
  arg1 = reinterpret_cast< ChromaSampleLocation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ChromaSampleLocation) /* defines _wrap_delete_ChromaSampleLocation_destructor_closure */

SWIGINTERN int _wrap_new_ResourceType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ResourceType",0,0,0)) SWIG_fail;
  result = (ResourceType *)new ResourceType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ResourceType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceType *arg1 = (ResourceType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ResourceType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResourceType" "', argument " "1"" of type '" "ResourceType *""'"); 
  }
  arg1 = reinterpret_cast< ResourceType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ResourceType) /* defines _wrap_delete_ResourceType_destructor_closure */

SWIGINTERN int _wrap_new_TextureType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_TextureType",0,0,0)) SWIG_fail;
  result = (TextureType *)new TextureType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_TextureType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureType *arg1 = (TextureType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TextureType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TextureType" "', argument " "1"" of type '" "TextureType *""'"); 
  }
  arg1 = reinterpret_cast< TextureType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TextureType) /* defines _wrap_delete_TextureType_destructor_closure */

SWIGINTERN int _wrap_new_BindType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BindType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_BindType",0,0,0)) SWIG_fail;
  result = (BindType *)new BindType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BindType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_BindType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BindType *arg1 = (BindType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_BindType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BindType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BindType" "', argument " "1"" of type '" "BindType *""'"); 
  }
  arg1 = reinterpret_cast< BindType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_BindType) /* defines _wrap_delete_BindType_destructor_closure */

SWIGINTERN int _wrap_new_DescriptorType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_DescriptorType",0,0,0)) SWIG_fail;
  result = (DescriptorType *)new DescriptorType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DescriptorType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_DescriptorType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorType *arg1 = (DescriptorType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DescriptorType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DescriptorType" "', argument " "1"" of type '" "DescriptorType *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DescriptorType) /* defines _wrap_delete_DescriptorType_destructor_closure */

SWIGINTERN int _wrap_new_DescriptorCategory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorCategory *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_DescriptorCategory",0,0,0)) SWIG_fail;
  result = (DescriptorCategory *)new DescriptorCategory();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DescriptorCategory, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_DescriptorCategory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorCategory *arg1 = (DescriptorCategory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DescriptorCategory",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorCategory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DescriptorCategory" "', argument " "1"" of type '" "DescriptorCategory *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorCategory * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DescriptorCategory) /* defines _wrap_delete_DescriptorCategory_destructor_closure */

SWIGINTERN PyObject *_wrap_CategoryForDescriptorType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  DescriptorCategory result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CategoryForDescriptorType" "', argument " "1"" of type '" "DescriptorType""'");
  } 
  arg1 = static_cast< DescriptorType >(val1);
  result = (DescriptorCategory)CategoryForDescriptorType(arg1);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_DescriptorCategory->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IsConstantBlockDescriptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsConstantBlockDescriptor" "', argument " "1"" of type '" "DescriptorType""'");
  } 
  arg1 = static_cast< DescriptorType >(val1);
  result = (bool)IsConstantBlockDescriptor(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IsSamplerDescriptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsSamplerDescriptor" "', argument " "1"" of type '" "DescriptorType""'");
  } 
  arg1 = static_cast< DescriptorType >(val1);
  result = (bool)IsSamplerDescriptor(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IsReadOnlyDescriptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsReadOnlyDescriptor" "', argument " "1"" of type '" "DescriptorType""'");
  } 
  arg1 = static_cast< DescriptorType >(val1);
  result = (bool)IsReadOnlyDescriptor(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IsReadWriteDescriptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsReadWriteDescriptor" "', argument " "1"" of type '" "DescriptorType""'");
  } 
  arg1 = static_cast< DescriptorType >(val1);
  result = (bool)IsReadWriteDescriptor(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_ShaderBuiltin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderBuiltin *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ShaderBuiltin",0,0,0)) SWIG_fail;
  result = (ShaderBuiltin *)new ShaderBuiltin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderBuiltin, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ShaderBuiltin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderBuiltin *arg1 = (ShaderBuiltin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderBuiltin",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderBuiltin, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderBuiltin" "', argument " "1"" of type '" "ShaderBuiltin *""'"); 
  }
  arg1 = reinterpret_cast< ShaderBuiltin * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderBuiltin) /* defines _wrap_delete_ShaderBuiltin_destructor_closure */

SWIGINTERN int _wrap_new_ReplayOutputType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOutputType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ReplayOutputType",0,0,0)) SWIG_fail;
  result = (ReplayOutputType *)new ReplayOutputType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ReplayOutputType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ReplayOutputType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOutputType *arg1 = (ReplayOutputType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ReplayOutputType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplayOutputType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReplayOutputType" "', argument " "1"" of type '" "ReplayOutputType *""'"); 
  }
  arg1 = reinterpret_cast< ReplayOutputType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ReplayOutputType) /* defines _wrap_delete_ReplayOutputType_destructor_closure */

SWIGINTERN int _wrap_new_MeshDataStage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDataStage *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_MeshDataStage",0,0,0)) SWIG_fail;
  result = (MeshDataStage *)new MeshDataStage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MeshDataStage, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_MeshDataStage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MeshDataStage *arg1 = (MeshDataStage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_MeshDataStage",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MeshDataStage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MeshDataStage" "', argument " "1"" of type '" "MeshDataStage *""'"); 
  }
  arg1 = reinterpret_cast< MeshDataStage * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_MeshDataStage) /* defines _wrap_delete_MeshDataStage_destructor_closure */

SWIGINTERN int _wrap_new_DebugOverlay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugOverlay *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_DebugOverlay",0,0,0)) SWIG_fail;
  result = (DebugOverlay *)new DebugOverlay();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DebugOverlay, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_DebugOverlay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugOverlay *arg1 = (DebugOverlay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DebugOverlay",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugOverlay, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DebugOverlay" "', argument " "1"" of type '" "DebugOverlay *""'"); 
  }
  arg1 = reinterpret_cast< DebugOverlay * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DebugOverlay) /* defines _wrap_delete_DebugOverlay_destructor_closure */

SWIGINTERN int _wrap_new_FileType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FileType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_FileType",0,0,0)) SWIG_fail;
  result = (FileType *)new FileType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FileType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FileType *arg1 = (FileType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_FileType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FileType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', argument " "1"" of type '" "FileType *""'"); 
  }
  arg1 = reinterpret_cast< FileType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_FileType) /* defines _wrap_delete_FileType_destructor_closure */

SWIGINTERN int _wrap_new_AlphaMapping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AlphaMapping *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_AlphaMapping",0,0,0)) SWIG_fail;
  result = (AlphaMapping *)new AlphaMapping();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AlphaMapping, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_AlphaMapping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AlphaMapping *arg1 = (AlphaMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_AlphaMapping",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_AlphaMapping, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlphaMapping" "', argument " "1"" of type '" "AlphaMapping *""'"); 
  }
  arg1 = reinterpret_cast< AlphaMapping * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_AlphaMapping) /* defines _wrap_delete_AlphaMapping_destructor_closure */

SWIGINTERN int _wrap_new_ResourceFormatType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormatType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ResourceFormatType",0,0,0)) SWIG_fail;
  result = (ResourceFormatType *)new ResourceFormatType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceFormatType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ResourceFormatType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceFormatType *arg1 = (ResourceFormatType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ResourceFormatType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceFormatType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResourceFormatType" "', argument " "1"" of type '" "ResourceFormatType *""'"); 
  }
  arg1 = reinterpret_cast< ResourceFormatType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ResourceFormatType) /* defines _wrap_delete_ResourceFormatType_destructor_closure */

SWIGINTERN int _wrap_new_QualityHint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QualityHint *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_QualityHint",0,0,0)) SWIG_fail;
  result = (QualityHint *)new QualityHint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QualityHint, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_QualityHint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QualityHint *arg1 = (QualityHint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_QualityHint",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_QualityHint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QualityHint" "', argument " "1"" of type '" "QualityHint *""'"); 
  }
  arg1 = reinterpret_cast< QualityHint * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_QualityHint) /* defines _wrap_delete_QualityHint_destructor_closure */

SWIGINTERN int _wrap_new_GPUVendor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUVendor *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_GPUVendor",0,0,0)) SWIG_fail;
  result = (GPUVendor *)new GPUVendor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GPUVendor, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_GPUVendor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUVendor *arg1 = (GPUVendor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GPUVendor",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUVendor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GPUVendor" "', argument " "1"" of type '" "GPUVendor *""'"); 
  }
  arg1 = reinterpret_cast< GPUVendor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GPUVendor) /* defines _wrap_delete_GPUVendor_destructor_closure */

SWIGINTERN PyObject *_wrap_GPUVendorFromPCIVendor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  GPUVendor result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GPUVendorFromPCIVendor" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  result = (GPUVendor)GPUVendorFromPCIVendor(arg1);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_GPUVendor->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_GraphicsAPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GraphicsAPI *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_GraphicsAPI",0,0,0)) SWIG_fail;
  result = (GraphicsAPI *)new GraphicsAPI();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GraphicsAPI, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_GraphicsAPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GraphicsAPI *arg1 = (GraphicsAPI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GraphicsAPI",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GraphicsAPI, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GraphicsAPI" "', argument " "1"" of type '" "GraphicsAPI *""'"); 
  }
  arg1 = reinterpret_cast< GraphicsAPI * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GraphicsAPI) /* defines _wrap_delete_GraphicsAPI_destructor_closure */

SWIGINTERN PyObject *_wrap_IsD3D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GraphicsAPI arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsD3D" "', argument " "1"" of type '" "GraphicsAPI""'");
  } 
  arg1 = static_cast< GraphicsAPI >(val1);
  result = (bool)IsD3D(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_ShaderEncoding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderEncoding *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ShaderEncoding",0,0,0)) SWIG_fail;
  result = (ShaderEncoding *)new ShaderEncoding();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderEncoding, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ShaderEncoding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderEncoding *arg1 = (ShaderEncoding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderEncoding",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderEncoding, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderEncoding" "', argument " "1"" of type '" "ShaderEncoding *""'"); 
  }
  arg1 = reinterpret_cast< ShaderEncoding * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderEncoding) /* defines _wrap_delete_ShaderEncoding_destructor_closure */

SWIGINTERN int _wrap_new_KnownShaderTool(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KnownShaderTool *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_KnownShaderTool",0,0,0)) SWIG_fail;
  result = (KnownShaderTool *)new KnownShaderTool();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KnownShaderTool, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_KnownShaderTool(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KnownShaderTool *arg1 = (KnownShaderTool *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_KnownShaderTool",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_KnownShaderTool, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KnownShaderTool" "', argument " "1"" of type '" "KnownShaderTool *""'"); 
  }
  arg1 = reinterpret_cast< KnownShaderTool * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_KnownShaderTool) /* defines _wrap_delete_KnownShaderTool_destructor_closure */

SWIGINTERN PyObject *_wrap_ToolExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KnownShaderTool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolExecutable" "', argument " "1"" of type '" "KnownShaderTool""'");
  } 
  arg1 = static_cast< KnownShaderTool >(val1);
  result = (char *)ToolExecutable(arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ToolInput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KnownShaderTool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderEncoding result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolInput" "', argument " "1"" of type '" "KnownShaderTool""'");
  } 
  arg1 = static_cast< KnownShaderTool >(val1);
  result = (ShaderEncoding)ToolInput(arg1);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderEncoding->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ToolOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KnownShaderTool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderEncoding result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolOutput" "', argument " "1"" of type '" "KnownShaderTool""'");
  } 
  arg1 = static_cast< KnownShaderTool >(val1);
  result = (ShaderEncoding)ToolOutput(arg1);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderEncoding->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IsTextRepresentation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderEncoding arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsTextRepresentation" "', argument " "1"" of type '" "ShaderEncoding""'");
  } 
  arg1 = static_cast< ShaderEncoding >(val1);
  result = (bool)IsTextRepresentation(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_Topology(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Topology *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_Topology",0,0,0)) SWIG_fail;
  result = (Topology *)new Topology();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Topology, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_Topology(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Topology *arg1 = (Topology *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_Topology",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Topology, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Topology" "', argument " "1"" of type '" "Topology *""'"); 
  }
  arg1 = reinterpret_cast< Topology * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_Topology) /* defines _wrap_delete_Topology_destructor_closure */

SWIGINTERN PyObject *_wrap_PatchList_Topology(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Topology result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PatchList_Topology" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  result = (Topology)PatchList_Topology(arg1);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_Topology->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PatchList_Count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Topology arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PatchList_Count" "', argument " "1"" of type '" "Topology""'");
  } 
  arg1 = static_cast< Topology >(val1);
  result = (uint32_t)PatchList_Count(arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IsStrip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Topology arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStrip" "', argument " "1"" of type '" "Topology""'");
  } 
  arg1 = static_cast< Topology >(val1);
  result = (bool)IsStrip(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_ShaderStage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderStage *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ShaderStage",0,0,0)) SWIG_fail;
  result = (ShaderStage *)new ShaderStage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderStage, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ShaderStage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderStage *arg1 = (ShaderStage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderStage",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderStage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderStage" "', argument " "1"" of type '" "ShaderStage *""'"); 
  }
  arg1 = reinterpret_cast< ShaderStage * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderStage) /* defines _wrap_delete_ShaderStage_destructor_closure */

SWIGINTERN int _wrap_new_MessageCategory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MessageCategory *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_MessageCategory",0,0,0)) SWIG_fail;
  result = (MessageCategory *)new MessageCategory();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MessageCategory, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_MessageCategory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MessageCategory *arg1 = (MessageCategory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_MessageCategory",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MessageCategory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageCategory" "', argument " "1"" of type '" "MessageCategory *""'"); 
  }
  arg1 = reinterpret_cast< MessageCategory * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_MessageCategory) /* defines _wrap_delete_MessageCategory_destructor_closure */

SWIGINTERN int _wrap_new_MessageSeverity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MessageSeverity *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_MessageSeverity",0,0,0)) SWIG_fail;
  result = (MessageSeverity *)new MessageSeverity();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MessageSeverity, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_MessageSeverity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MessageSeverity *arg1 = (MessageSeverity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_MessageSeverity",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MessageSeverity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageSeverity" "', argument " "1"" of type '" "MessageSeverity *""'"); 
  }
  arg1 = reinterpret_cast< MessageSeverity * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_MessageSeverity) /* defines _wrap_delete_MessageSeverity_destructor_closure */

SWIGINTERN int _wrap_new_MessageSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MessageSource *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_MessageSource",0,0,0)) SWIG_fail;
  result = (MessageSource *)new MessageSource();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MessageSource, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_MessageSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MessageSource *arg1 = (MessageSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_MessageSource",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MessageSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageSource" "', argument " "1"" of type '" "MessageSource *""'"); 
  }
  arg1 = reinterpret_cast< MessageSource * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_MessageSource) /* defines _wrap_delete_MessageSource_destructor_closure */

SWIGINTERN int _wrap_new_ResourceUsage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceUsage *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ResourceUsage",0,0,0)) SWIG_fail;
  result = (ResourceUsage *)new ResourceUsage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceUsage, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ResourceUsage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResourceUsage *arg1 = (ResourceUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ResourceUsage",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResourceUsage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResourceUsage" "', argument " "1"" of type '" "ResourceUsage *""'"); 
  }
  arg1 = reinterpret_cast< ResourceUsage * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ResourceUsage) /* defines _wrap_delete_ResourceUsage_destructor_closure */

SWIGINTERN PyObject *_wrap_CBUsage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderStage arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceUsage result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CBUsage" "', argument " "1"" of type '" "ShaderStage""'");
  } 
  arg1 = static_cast< ShaderStage >(val1);
  result = (ResourceUsage)CBUsage(arg1);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ResourceUsage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResUsage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderStage arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceUsage result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ResUsage" "', argument " "1"" of type '" "ShaderStage""'");
  } 
  arg1 = static_cast< ShaderStage >(val1);
  result = (ResourceUsage)ResUsage(arg1);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ResourceUsage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RWResUsage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderStage arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceUsage result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RWResUsage" "', argument " "1"" of type '" "ShaderStage""'");
  } 
  arg1 = static_cast< ShaderStage >(val1);
  result = (ResourceUsage)RWResUsage(arg1);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ResourceUsage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_Visualisation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Visualisation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_Visualisation",0,0,0)) SWIG_fail;
  result = (Visualisation *)new Visualisation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Visualisation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_Visualisation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Visualisation *arg1 = (Visualisation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_Visualisation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Visualisation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Visualisation" "', argument " "1"" of type '" "Visualisation *""'"); 
  }
  arg1 = reinterpret_cast< Visualisation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_Visualisation) /* defines _wrap_delete_Visualisation_destructor_closure */

SWIGINTERN int _wrap_new_FillMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FillMode *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_FillMode",0,0,0)) SWIG_fail;
  result = (FillMode *)new FillMode();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FillMode, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_FillMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FillMode *arg1 = (FillMode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_FillMode",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FillMode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FillMode" "', argument " "1"" of type '" "FillMode *""'"); 
  }
  arg1 = reinterpret_cast< FillMode * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_FillMode) /* defines _wrap_delete_FillMode_destructor_closure */

SWIGINTERN int _wrap_new_CullMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CullMode *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_CullMode",0,0,0)) SWIG_fail;
  result = (CullMode *)new CullMode();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CullMode, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_CullMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CullMode *arg1 = (CullMode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_CullMode",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CullMode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CullMode" "', argument " "1"" of type '" "CullMode *""'"); 
  }
  arg1 = reinterpret_cast< CullMode * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CullMode) /* defines _wrap_delete_CullMode_destructor_closure */

SWIGINTERN int _wrap_new_ConservativeRaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConservativeRaster *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ConservativeRaster",0,0,0)) SWIG_fail;
  result = (ConservativeRaster *)new ConservativeRaster();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConservativeRaster, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ConservativeRaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConservativeRaster *arg1 = (ConservativeRaster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ConservativeRaster",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConservativeRaster, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConservativeRaster" "', argument " "1"" of type '" "ConservativeRaster *""'"); 
  }
  arg1 = reinterpret_cast< ConservativeRaster * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ConservativeRaster) /* defines _wrap_delete_ConservativeRaster_destructor_closure */

SWIGINTERN int _wrap_new_ShadingRateCombiner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShadingRateCombiner *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ShadingRateCombiner",0,0,0)) SWIG_fail;
  result = (ShadingRateCombiner *)new ShadingRateCombiner();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShadingRateCombiner, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ShadingRateCombiner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShadingRateCombiner *arg1 = (ShadingRateCombiner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShadingRateCombiner",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShadingRateCombiner, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShadingRateCombiner" "', argument " "1"" of type '" "ShadingRateCombiner *""'"); 
  }
  arg1 = reinterpret_cast< ShadingRateCombiner * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShadingRateCombiner) /* defines _wrap_delete_ShadingRateCombiner_destructor_closure */

SWIGINTERN int _wrap_new_LineRaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineRaster *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_LineRaster",0,0,0)) SWIG_fail;
  result = (LineRaster *)new LineRaster();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LineRaster, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_LineRaster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineRaster *arg1 = (LineRaster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_LineRaster",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineRaster, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LineRaster" "', argument " "1"" of type '" "LineRaster *""'"); 
  }
  arg1 = reinterpret_cast< LineRaster * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_LineRaster) /* defines _wrap_delete_LineRaster_destructor_closure */

SWIGINTERN int _wrap_new_FilterMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FilterMode *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_FilterMode",0,0,0)) SWIG_fail;
  result = (FilterMode *)new FilterMode();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FilterMode, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_FilterMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FilterMode *arg1 = (FilterMode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_FilterMode",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FilterMode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FilterMode" "', argument " "1"" of type '" "FilterMode *""'"); 
  }
  arg1 = reinterpret_cast< FilterMode * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_FilterMode) /* defines _wrap_delete_FilterMode_destructor_closure */

SWIGINTERN int _wrap_new_FilterFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FilterFunction *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_FilterFunction",0,0,0)) SWIG_fail;
  result = (FilterFunction *)new FilterFunction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FilterFunction, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_FilterFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FilterFunction *arg1 = (FilterFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_FilterFunction",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FilterFunction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FilterFunction" "', argument " "1"" of type '" "FilterFunction *""'"); 
  }
  arg1 = reinterpret_cast< FilterFunction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_FilterFunction) /* defines _wrap_delete_FilterFunction_destructor_closure */

SWIGINTERN int _wrap_new_CompareFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CompareFunction *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_CompareFunction",0,0,0)) SWIG_fail;
  result = (CompareFunction *)new CompareFunction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompareFunction, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_CompareFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CompareFunction *arg1 = (CompareFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_CompareFunction",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CompareFunction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CompareFunction" "', argument " "1"" of type '" "CompareFunction *""'"); 
  }
  arg1 = reinterpret_cast< CompareFunction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CompareFunction) /* defines _wrap_delete_CompareFunction_destructor_closure */

SWIGINTERN int _wrap_new_StencilOperation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilOperation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_StencilOperation",0,0,0)) SWIG_fail;
  result = (StencilOperation *)new StencilOperation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StencilOperation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_StencilOperation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StencilOperation *arg1 = (StencilOperation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_StencilOperation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_StencilOperation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StencilOperation" "', argument " "1"" of type '" "StencilOperation *""'"); 
  }
  arg1 = reinterpret_cast< StencilOperation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_StencilOperation) /* defines _wrap_delete_StencilOperation_destructor_closure */

SWIGINTERN int _wrap_new_BlendMultiplier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendMultiplier *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_BlendMultiplier",0,0,0)) SWIG_fail;
  result = (BlendMultiplier *)new BlendMultiplier();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BlendMultiplier, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_BlendMultiplier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendMultiplier *arg1 = (BlendMultiplier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_BlendMultiplier",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendMultiplier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlendMultiplier" "', argument " "1"" of type '" "BlendMultiplier *""'"); 
  }
  arg1 = reinterpret_cast< BlendMultiplier * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_BlendMultiplier) /* defines _wrap_delete_BlendMultiplier_destructor_closure */

SWIGINTERN int _wrap_new_BlendOperation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendOperation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_BlendOperation",0,0,0)) SWIG_fail;
  result = (BlendOperation *)new BlendOperation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BlendOperation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_BlendOperation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlendOperation *arg1 = (BlendOperation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_BlendOperation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BlendOperation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlendOperation" "', argument " "1"" of type '" "BlendOperation *""'"); 
  }
  arg1 = reinterpret_cast< BlendOperation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_BlendOperation) /* defines _wrap_delete_BlendOperation_destructor_closure */

SWIGINTERN int _wrap_new_LogicOperation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LogicOperation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_LogicOperation",0,0,0)) SWIG_fail;
  result = (LogicOperation *)new LogicOperation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LogicOperation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_LogicOperation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LogicOperation *arg1 = (LogicOperation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_LogicOperation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LogicOperation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogicOperation" "', argument " "1"" of type '" "LogicOperation *""'"); 
  }
  arg1 = reinterpret_cast< LogicOperation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_LogicOperation) /* defines _wrap_delete_LogicOperation_destructor_closure */

SWIGINTERN int _wrap_new_GPUCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUCounter *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_GPUCounter",0,0,0)) SWIG_fail;
  result = (GPUCounter *)new GPUCounter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GPUCounter, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_GPUCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUCounter *arg1 = (GPUCounter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_GPUCounter",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPUCounter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GPUCounter" "', argument " "1"" of type '" "GPUCounter *""'"); 
  }
  arg1 = reinterpret_cast< GPUCounter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_GPUCounter) /* defines _wrap_delete_GPUCounter_destructor_closure */

SWIGINTERN PyObject *_wrap_IsGenericCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUCounter arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsGenericCounter" "', argument " "1"" of type '" "GPUCounter""'");
  } 
  arg1 = static_cast< GPUCounter >(val1);
  result = (bool)IsGenericCounter(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IsAMDCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUCounter arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsAMDCounter" "', argument " "1"" of type '" "GPUCounter""'");
  } 
  arg1 = static_cast< GPUCounter >(val1);
  result = (bool)IsAMDCounter(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IsIntelCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUCounter arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsIntelCounter" "', argument " "1"" of type '" "GPUCounter""'");
  } 
  arg1 = static_cast< GPUCounter >(val1);
  result = (bool)IsIntelCounter(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IsNvidiaCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUCounter arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsNvidiaCounter" "', argument " "1"" of type '" "GPUCounter""'");
  } 
  arg1 = static_cast< GPUCounter >(val1);
  result = (bool)IsNvidiaCounter(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IsVulkanExtendedCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUCounter arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsVulkanExtendedCounter" "', argument " "1"" of type '" "GPUCounter""'");
  } 
  arg1 = static_cast< GPUCounter >(val1);
  result = (bool)IsVulkanExtendedCounter(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IsARMCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GPUCounter arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsARMCounter" "', argument " "1"" of type '" "GPUCounter""'");
  } 
  arg1 = static_cast< GPUCounter >(val1);
  result = (bool)IsARMCounter(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_CounterUnit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterUnit *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_CounterUnit",0,0,0)) SWIG_fail;
  result = (CounterUnit *)new CounterUnit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CounterUnit, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_CounterUnit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CounterUnit *arg1 = (CounterUnit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_CounterUnit",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CounterUnit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CounterUnit" "', argument " "1"" of type '" "CounterUnit *""'"); 
  }
  arg1 = reinterpret_cast< CounterUnit * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CounterUnit) /* defines _wrap_delete_CounterUnit_destructor_closure */

SWIGINTERN int _wrap_new_CameraType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CameraType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_CameraType",0,0,0)) SWIG_fail;
  result = (CameraType *)new CameraType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CameraType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_CameraType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CameraType *arg1 = (CameraType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_CameraType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CameraType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CameraType" "', argument " "1"" of type '" "CameraType *""'"); 
  }
  arg1 = reinterpret_cast< CameraType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_CameraType) /* defines _wrap_delete_CameraType_destructor_closure */

SWIGINTERN int _wrap_new_ReplaySupport(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplaySupport *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ReplaySupport",0,0,0)) SWIG_fail;
  result = (ReplaySupport *)new ReplaySupport();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ReplaySupport, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ReplaySupport(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplaySupport *arg1 = (ReplaySupport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ReplaySupport",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplaySupport, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReplaySupport" "', argument " "1"" of type '" "ReplaySupport *""'"); 
  }
  arg1 = reinterpret_cast< ReplaySupport * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ReplaySupport) /* defines _wrap_delete_ReplaySupport_destructor_closure */

SWIGINTERN int _wrap_new_ResultCode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResultCode *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ResultCode",0,0,0)) SWIG_fail;
  result = (ResultCode *)new ResultCode();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResultCode, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ResultCode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ResultCode *arg1 = (ResultCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ResultCode",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ResultCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResultCode" "', argument " "1"" of type '" "ResultCode *""'"); 
  }
  arg1 = reinterpret_cast< ResultCode * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ResultCode) /* defines _wrap_delete_ResultCode_destructor_closure */

SWIGINTERN int _wrap_new_TargetControlMessageType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessageType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_TargetControlMessageType",0,0,0)) SWIG_fail;
  result = (TargetControlMessageType *)new TargetControlMessageType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TargetControlMessageType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_TargetControlMessageType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TargetControlMessageType *arg1 = (TargetControlMessageType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TargetControlMessageType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TargetControlMessageType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TargetControlMessageType" "', argument " "1"" of type '" "TargetControlMessageType *""'"); 
  }
  arg1 = reinterpret_cast< TargetControlMessageType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TargetControlMessageType) /* defines _wrap_delete_TargetControlMessageType_destructor_closure */

SWIGINTERN int _wrap_new_EnvMod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvMod *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_EnvMod",0,0,0)) SWIG_fail;
  result = (EnvMod *)new EnvMod();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EnvMod, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_EnvMod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvMod *arg1 = (EnvMod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_EnvMod",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvMod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EnvMod" "', argument " "1"" of type '" "EnvMod *""'"); 
  }
  arg1 = reinterpret_cast< EnvMod * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_EnvMod) /* defines _wrap_delete_EnvMod_destructor_closure */

SWIGINTERN int _wrap_new_EnvSep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvSep *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_EnvSep",0,0,0)) SWIG_fail;
  result = (EnvSep *)new EnvSep();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EnvSep, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_EnvSep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EnvSep *arg1 = (EnvSep *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_EnvSep",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EnvSep, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EnvSep" "', argument " "1"" of type '" "EnvSep *""'"); 
  }
  arg1 = reinterpret_cast< EnvSep * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_EnvSep) /* defines _wrap_delete_EnvSep_destructor_closure */

SWIGINTERN int _wrap_new_LogType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LogType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_LogType",0,0,0)) SWIG_fail;
  result = (LogType *)new LogType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LogType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_LogType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LogType *arg1 = (LogType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_LogType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LogType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogType" "', argument " "1"" of type '" "LogType *""'"); 
  }
  arg1 = reinterpret_cast< LogType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_LogType) /* defines _wrap_delete_LogType_destructor_closure */

SWIGINTERN int _wrap_new_ReplayOptimisationLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOptimisationLevel *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ReplayOptimisationLevel",0,0,0)) SWIG_fail;
  result = (ReplayOptimisationLevel *)new ReplayOptimisationLevel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ReplayOptimisationLevel, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ReplayOptimisationLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReplayOptimisationLevel *arg1 = (ReplayOptimisationLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ReplayOptimisationLevel",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ReplayOptimisationLevel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReplayOptimisationLevel" "', argument " "1"" of type '" "ReplayOptimisationLevel *""'"); 
  }
  arg1 = reinterpret_cast< ReplayOptimisationLevel * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ReplayOptimisationLevel) /* defines _wrap_delete_ReplayOptimisationLevel_destructor_closure */

SWIGINTERN int _wrap_new_WindowingSystem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  WindowingSystem *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_WindowingSystem",0,0,0)) SWIG_fail;
  result = (WindowingSystem *)new WindowingSystem();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_WindowingSystem, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_WindowingSystem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  WindowingSystem *arg1 = (WindowingSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_WindowingSystem",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_WindowingSystem, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowingSystem" "', argument " "1"" of type '" "WindowingSystem *""'"); 
  }
  arg1 = reinterpret_cast< WindowingSystem * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_WindowingSystem) /* defines _wrap_delete_WindowingSystem_destructor_closure */

SWIGINTERN int _wrap_new_PathProperty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathProperty *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_PathProperty",0,0,0)) SWIG_fail;
  result = (PathProperty *)new PathProperty();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PathProperty, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_PathProperty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathProperty *arg1 = (PathProperty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_PathProperty",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PathProperty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PathProperty" "', argument " "1"" of type '" "PathProperty *""'"); 
  }
  arg1 = reinterpret_cast< PathProperty * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_PathProperty) /* defines _wrap_delete_PathProperty_destructor_closure */

SWIGINTERN int _wrap_new_SectionFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionFlags *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_SectionFlags",0,0,0)) SWIG_fail;
  result = (SectionFlags *)new SectionFlags();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SectionFlags, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_SectionFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SectionFlags *arg1 = (SectionFlags *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_SectionFlags",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SectionFlags, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SectionFlags" "', argument " "1"" of type '" "SectionFlags *""'"); 
  }
  arg1 = reinterpret_cast< SectionFlags * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_SectionFlags) /* defines _wrap_delete_SectionFlags_destructor_closure */

SWIGINTERN int _wrap_new_BufferCategory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferCategory *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_BufferCategory",0,0,0)) SWIG_fail;
  result = (BufferCategory *)new BufferCategory();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BufferCategory, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_BufferCategory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BufferCategory *arg1 = (BufferCategory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_BufferCategory",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_BufferCategory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BufferCategory" "', argument " "1"" of type '" "BufferCategory *""'"); 
  }
  arg1 = reinterpret_cast< BufferCategory * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_BufferCategory) /* defines _wrap_delete_BufferCategory_destructor_closure */

SWIGINTERN int _wrap_new_DescriptorFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorFlags *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_DescriptorFlags",0,0,0)) SWIG_fail;
  result = (DescriptorFlags *)new DescriptorFlags();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DescriptorFlags, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_DescriptorFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DescriptorFlags *arg1 = (DescriptorFlags *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DescriptorFlags",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DescriptorFlags, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DescriptorFlags" "', argument " "1"" of type '" "DescriptorFlags *""'"); 
  }
  arg1 = reinterpret_cast< DescriptorFlags * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DescriptorFlags) /* defines _wrap_delete_DescriptorFlags_destructor_closure */

SWIGINTERN int _wrap_new_TextureCategory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureCategory *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_TextureCategory",0,0,0)) SWIG_fail;
  result = (TextureCategory *)new TextureCategory();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TextureCategory, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_TextureCategory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TextureCategory *arg1 = (TextureCategory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_TextureCategory",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextureCategory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TextureCategory" "', argument " "1"" of type '" "TextureCategory *""'"); 
  }
  arg1 = reinterpret_cast< TextureCategory * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_TextureCategory) /* defines _wrap_delete_TextureCategory_destructor_closure */

SWIGINTERN int _wrap_new_ShaderStageMask(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderStageMask *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ShaderStageMask",0,0,0)) SWIG_fail;
  result = (ShaderStageMask *)new ShaderStageMask();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderStageMask, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ShaderStageMask(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderStageMask *arg1 = (ShaderStageMask *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderStageMask",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderStageMask, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderStageMask" "', argument " "1"" of type '" "ShaderStageMask *""'"); 
  }
  arg1 = reinterpret_cast< ShaderStageMask * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderStageMask) /* defines _wrap_delete_ShaderStageMask_destructor_closure */

SWIGINTERN PyObject *_wrap_MaskForStage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderStage arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStageMask result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MaskForStage" "', argument " "1"" of type '" "ShaderStage""'");
  } 
  arg1 = static_cast< ShaderStage >(val1);
  result = (ShaderStageMask)MaskForStage(arg1);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStageMask->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FirstStageForMask(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderStageMask arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStage result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FirstStageForMask" "', argument " "1"" of type '" "ShaderStageMask""'");
  } 
  arg1 = static_cast< ShaderStageMask >(val1);
  result = (ShaderStage)FirstStageForMask(arg1);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_ShaderEvents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderEvents *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ShaderEvents",0,0,0)) SWIG_fail;
  result = (ShaderEvents *)new ShaderEvents();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderEvents, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ShaderEvents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderEvents *arg1 = (ShaderEvents *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderEvents",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderEvents, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderEvents" "', argument " "1"" of type '" "ShaderEvents *""'"); 
  }
  arg1 = reinterpret_cast< ShaderEvents * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderEvents) /* defines _wrap_delete_ShaderEvents_destructor_closure */

SWIGINTERN int _wrap_new_ShaderVariableFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariableFlags *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ShaderVariableFlags",0,0,0)) SWIG_fail;
  result = (ShaderVariableFlags *)new ShaderVariableFlags();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderVariableFlags, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ShaderVariableFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariableFlags *arg1 = (ShaderVariableFlags *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderVariableFlags",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariableFlags, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderVariableFlags" "', argument " "1"" of type '" "ShaderVariableFlags *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariableFlags * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderVariableFlags) /* defines _wrap_delete_ShaderVariableFlags_destructor_closure */

SWIGINTERN int _wrap_new_ActionFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionFlags *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ActionFlags",0,0,0)) SWIG_fail;
  result = (ActionFlags *)new ActionFlags();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ActionFlags, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ActionFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ActionFlags *arg1 = (ActionFlags *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ActionFlags",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ActionFlags, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ActionFlags" "', argument " "1"" of type '" "ActionFlags *""'"); 
  }
  arg1 = reinterpret_cast< ActionFlags * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ActionFlags) /* defines _wrap_delete_ActionFlags_destructor_closure */

SWIGINTERN int _wrap_new_VulkanLayerFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VulkanLayerFlags *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_VulkanLayerFlags",0,0,0)) SWIG_fail;
  result = (VulkanLayerFlags *)new VulkanLayerFlags();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VulkanLayerFlags, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_VulkanLayerFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VulkanLayerFlags *arg1 = (VulkanLayerFlags *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VulkanLayerFlags",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VulkanLayerFlags, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VulkanLayerFlags" "', argument " "1"" of type '" "VulkanLayerFlags *""'"); 
  }
  arg1 = reinterpret_cast< VulkanLayerFlags * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VulkanLayerFlags) /* defines _wrap_delete_VulkanLayerFlags_destructor_closure */

SWIGINTERN int _wrap_new_AndroidFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AndroidFlags *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_AndroidFlags",0,0,0)) SWIG_fail;
  result = (AndroidFlags *)new AndroidFlags();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AndroidFlags, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_AndroidFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AndroidFlags *arg1 = (AndroidFlags *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_AndroidFlags",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_AndroidFlags, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AndroidFlags" "', argument " "1"" of type '" "AndroidFlags *""'"); 
  }
  arg1 = reinterpret_cast< AndroidFlags * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_AndroidFlags) /* defines _wrap_delete_AndroidFlags_destructor_closure */

SWIGINTERN int _wrap_new_PointerVal__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  PointerVal *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (PointerVal *)new PointerVal();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PointerVal, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_PointerVal__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PointerVal *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PointerVal *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_PointerVal,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PointerVal" "', argument " "1"" of type '" "PointerVal const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PointerVal" "', argument " "1"" of type '" "PointerVal const &""'"); 
  }
  arg1 = reinterpret_cast< PointerVal * >(argp1);
  result = (PointerVal *)new PointerVal((PointerVal const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PointerVal, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_PointerVal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_PointerVal",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_PointerVal__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_PointerVal__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PointerVal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PointerVal::PointerVal()\n"
    "    PointerVal::PointerVal(PointerVal const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_PointerVal_pointer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PointerVal *arg1 = (PointerVal *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PointerVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PointerVal_pointer_set" "', argument " "1"" of type '" "PointerVal *""'"); 
  }
  arg1 = reinterpret_cast< PointerVal * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PointerVal_pointer_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->pointer = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PointerVal_pointer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PointerVal *arg1 = (PointerVal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"PointerVal_pointer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PointerVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PointerVal_pointer_get" "', argument " "1"" of type '" "PointerVal *""'"); 
  }
  arg1 = reinterpret_cast< PointerVal * >(argp1);
  result = (uint64_t) ((arg1)->pointer);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PointerVal_shader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PointerVal *arg1 = (PointerVal *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PointerVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PointerVal_shader_set" "', argument " "1"" of type '" "PointerVal *""'"); 
  }
  arg1 = reinterpret_cast< PointerVal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PointerVal_shader_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->shader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PointerVal_shader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PointerVal *arg1 = (PointerVal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"PointerVal_shader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PointerVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PointerVal_shader_get" "', argument " "1"" of type '" "PointerVal *""'"); 
  }
  arg1 = reinterpret_cast< PointerVal * >(argp1);
  result = (ResourceId *)& ((arg1)->shader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PointerVal_pointerTypeID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PointerVal *arg1 = (PointerVal *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PointerVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PointerVal_pointerTypeID_set" "', argument " "1"" of type '" "PointerVal *""'"); 
  }
  arg1 = reinterpret_cast< PointerVal * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PointerVal_pointerTypeID_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->pointerTypeID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PointerVal_pointerTypeID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PointerVal *arg1 = (PointerVal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"PointerVal_pointerTypeID_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PointerVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PointerVal_pointerTypeID_get" "', argument " "1"" of type '" "PointerVal *""'"); 
  }
  arg1 = reinterpret_cast< PointerVal * >(argp1);
  result = (uint32_t) ((arg1)->pointerTypeID);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PointerVal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PointerVal *arg1 = (PointerVal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_PointerVal",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PointerVal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PointerVal" "', argument " "1"" of type '" "PointerVal *""'"); 
  }
  arg1 = reinterpret_cast< PointerVal * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_PointerVal) /* defines _wrap_delete_PointerVal_destructor_closure */

SWIGINTERN int _wrap_new_ShaderBindIndex__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderBindIndex *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderBindIndex *)new ShaderBindIndex();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderBindIndex, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderBindIndex__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderBindIndex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderBindIndex *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderBindIndex,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderBindIndex" "', argument " "1"" of type '" "ShaderBindIndex const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderBindIndex" "', argument " "1"" of type '" "ShaderBindIndex const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderBindIndex * >(argp1);
  result = (ShaderBindIndex *)new ShaderBindIndex((ShaderBindIndex const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderBindIndex, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderBindIndex__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DescriptorCategory arg1 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  ShaderBindIndex *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShaderBindIndex" "', argument " "1"" of type '" "DescriptorCategory""'");
  } 
  arg1 = static_cast< DescriptorCategory >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShaderBindIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ShaderBindIndex" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  result = (ShaderBindIndex *)new ShaderBindIndex(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderBindIndex, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderBindIndex__SWIG_3(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DescriptorCategory arg1 ;
  uint32_t arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ShaderBindIndex *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShaderBindIndex" "', argument " "1"" of type '" "DescriptorCategory""'");
  } 
  arg1 = static_cast< DescriptorCategory >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShaderBindIndex" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  result = (ShaderBindIndex *)new ShaderBindIndex(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderBindIndex, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderBindIndex__SWIG_4(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderBindIndex *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DescriptorAccess,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderBindIndex" "', argument " "1"" of type '" "DescriptorAccess const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderBindIndex" "', argument " "1"" of type '" "DescriptorAccess const &""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  result = (ShaderBindIndex *)new ShaderBindIndex((DescriptorAccess const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderBindIndex, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderBindIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderBindIndex",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderBindIndex__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ShaderBindIndex, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_ShaderBindIndex__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    return _wrap_new_ShaderBindIndex__SWIG_4(self, argc, argv);
  }
  if (argc == 2) {
    return _wrap_new_ShaderBindIndex__SWIG_3(self, argc, argv);
  }
  if (argc == 3) {
    return _wrap_new_ShaderBindIndex__SWIG_2(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderBindIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderBindIndex::ShaderBindIndex()\n"
    "    ShaderBindIndex::ShaderBindIndex(ShaderBindIndex const &)\n"
    "    ShaderBindIndex::ShaderBindIndex(DescriptorCategory,uint32_t,uint32_t)\n"
    "    ShaderBindIndex::ShaderBindIndex(DescriptorCategory,uint32_t)\n"
    "    ShaderBindIndex::ShaderBindIndex(DescriptorAccess const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderBindIndex___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderBindIndex *arg1 = (ShaderBindIndex *) 0 ;
  ShaderBindIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderBindIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderBindIndex___lt__" "', argument " "1"" of type '" "ShaderBindIndex const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderBindIndex * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderBindIndex,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderBindIndex___lt__" "', argument " "2"" of type '" "ShaderBindIndex const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderBindIndex___lt__" "', argument " "2"" of type '" "ShaderBindIndex const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderBindIndex * >(argp2);
  result = (bool)((ShaderBindIndex const *)arg1)->operator <((ShaderBindIndex const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderBindIndex___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderBindIndex *arg1 = (ShaderBindIndex *) 0 ;
  ShaderBindIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderBindIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderBindIndex___gt__" "', argument " "1"" of type '" "ShaderBindIndex const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderBindIndex * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderBindIndex,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderBindIndex___gt__" "', argument " "2"" of type '" "ShaderBindIndex const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderBindIndex___gt__" "', argument " "2"" of type '" "ShaderBindIndex const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderBindIndex * >(argp2);
  result = (bool)((ShaderBindIndex const *)arg1)->operator >((ShaderBindIndex const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderBindIndex___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderBindIndex *arg1 = (ShaderBindIndex *) 0 ;
  ShaderBindIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderBindIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderBindIndex___eq__" "', argument " "1"" of type '" "ShaderBindIndex const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderBindIndex * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderBindIndex,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderBindIndex___eq__" "', argument " "2"" of type '" "ShaderBindIndex const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderBindIndex___eq__" "', argument " "2"" of type '" "ShaderBindIndex const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderBindIndex * >(argp2);
  result = (bool)((ShaderBindIndex const *)arg1)->operator ==((ShaderBindIndex const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderBindIndex_category_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderBindIndex *arg1 = (ShaderBindIndex *) 0 ;
  DescriptorCategory arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderBindIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderBindIndex_category_set" "', argument " "1"" of type '" "ShaderBindIndex *""'"); 
  }
  arg1 = reinterpret_cast< ShaderBindIndex * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderBindIndex_category_set" "', argument " "2"" of type '" "DescriptorCategory""'");
  } 
  arg2 = static_cast< DescriptorCategory >(val2);
  if (arg1) (arg1)->category = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderBindIndex_category_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderBindIndex *arg1 = (ShaderBindIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DescriptorCategory result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderBindIndex_category_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderBindIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderBindIndex_category_get" "', argument " "1"" of type '" "ShaderBindIndex *""'"); 
  }
  arg1 = reinterpret_cast< ShaderBindIndex * >(argp1);
  result = (DescriptorCategory) ((arg1)->category);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_DescriptorCategory->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderBindIndex_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderBindIndex *arg1 = (ShaderBindIndex *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderBindIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderBindIndex_index_set" "', argument " "1"" of type '" "ShaderBindIndex *""'"); 
  }
  arg1 = reinterpret_cast< ShaderBindIndex * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderBindIndex_index_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderBindIndex_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderBindIndex *arg1 = (ShaderBindIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderBindIndex_index_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderBindIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderBindIndex_index_get" "', argument " "1"" of type '" "ShaderBindIndex *""'"); 
  }
  arg1 = reinterpret_cast< ShaderBindIndex * >(argp1);
  result = (uint32_t) ((arg1)->index);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderBindIndex_arrayElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderBindIndex *arg1 = (ShaderBindIndex *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderBindIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderBindIndex_arrayElement_set" "', argument " "1"" of type '" "ShaderBindIndex *""'"); 
  }
  arg1 = reinterpret_cast< ShaderBindIndex * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderBindIndex_arrayElement_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->arrayElement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderBindIndex_arrayElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderBindIndex *arg1 = (ShaderBindIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderBindIndex_arrayElement_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderBindIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderBindIndex_arrayElement_get" "', argument " "1"" of type '" "ShaderBindIndex *""'"); 
  }
  arg1 = reinterpret_cast< ShaderBindIndex * >(argp1);
  result = (uint32_t) ((arg1)->arrayElement);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderBindIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderBindIndex *arg1 = (ShaderBindIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderBindIndex",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderBindIndex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderBindIndex" "', argument " "1"" of type '" "ShaderBindIndex *""'"); 
  }
  arg1 = reinterpret_cast< ShaderBindIndex * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderBindIndex) /* defines _wrap_delete_ShaderBindIndex_destructor_closure */

SWIGINTERN int _wrap_new_ShaderDirectAccess__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderDirectAccess *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderDirectAccess *)new ShaderDirectAccess();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDirectAccess, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderDirectAccess__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderDirectAccess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderDirectAccess *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderDirectAccess,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderDirectAccess" "', argument " "1"" of type '" "ShaderDirectAccess const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderDirectAccess" "', argument " "1"" of type '" "ShaderDirectAccess const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderDirectAccess * >(argp1);
  result = (ShaderDirectAccess *)new ShaderDirectAccess((ShaderDirectAccess const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDirectAccess, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderDirectAccess__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DescriptorType arg1 ;
  ResourceId arg2 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  ShaderDirectAccess *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShaderDirectAccess" "', argument " "1"" of type '" "DescriptorType""'");
  } 
  arg1 = static_cast< DescriptorType >(val1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ShaderDirectAccess" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderDirectAccess" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ShaderDirectAccess" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ShaderDirectAccess" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  result = (ShaderDirectAccess *)new ShaderDirectAccess(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDirectAccess, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderDirectAccess__SWIG_3(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DescriptorAccess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderDirectAccess *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DescriptorAccess,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderDirectAccess" "', argument " "1"" of type '" "DescriptorAccess const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderDirectAccess" "', argument " "1"" of type '" "DescriptorAccess const &""'"); 
  }
  arg1 = reinterpret_cast< DescriptorAccess * >(argp1);
  result = (ShaderDirectAccess *)new ShaderDirectAccess((DescriptorAccess const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDirectAccess, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderDirectAccess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderDirectAccess",0,4,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderDirectAccess__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ShaderDirectAccess, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_ShaderDirectAccess__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    return _wrap_new_ShaderDirectAccess__SWIG_3(self, argc, argv);
  }
  if (argc == 4) {
    return _wrap_new_ShaderDirectAccess__SWIG_2(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderDirectAccess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderDirectAccess::ShaderDirectAccess()\n"
    "    ShaderDirectAccess::ShaderDirectAccess(ShaderDirectAccess const &)\n"
    "    ShaderDirectAccess::ShaderDirectAccess(DescriptorType,ResourceId,uint32_t,uint32_t)\n"
    "    ShaderDirectAccess::ShaderDirectAccess(DescriptorAccess const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderDirectAccess___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDirectAccess *arg1 = (ShaderDirectAccess *) 0 ;
  ShaderDirectAccess *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDirectAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDirectAccess___lt__" "', argument " "1"" of type '" "ShaderDirectAccess const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDirectAccess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderDirectAccess,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderDirectAccess___lt__" "', argument " "2"" of type '" "ShaderDirectAccess const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderDirectAccess___lt__" "', argument " "2"" of type '" "ShaderDirectAccess const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderDirectAccess * >(argp2);
  result = (bool)((ShaderDirectAccess const *)arg1)->operator <((ShaderDirectAccess const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDirectAccess___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDirectAccess *arg1 = (ShaderDirectAccess *) 0 ;
  ShaderDirectAccess *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDirectAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDirectAccess___eq__" "', argument " "1"" of type '" "ShaderDirectAccess const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDirectAccess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderDirectAccess,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderDirectAccess___eq__" "', argument " "2"" of type '" "ShaderDirectAccess const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderDirectAccess___eq__" "', argument " "2"" of type '" "ShaderDirectAccess const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderDirectAccess * >(argp2);
  result = (bool)((ShaderDirectAccess const *)arg1)->operator ==((ShaderDirectAccess const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDirectAccess_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDirectAccess *arg1 = (ShaderDirectAccess *) 0 ;
  DescriptorType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDirectAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDirectAccess_type_set" "', argument " "1"" of type '" "ShaderDirectAccess *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDirectAccess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderDirectAccess_type_set" "', argument " "2"" of type '" "DescriptorType""'");
  } 
  arg2 = static_cast< DescriptorType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDirectAccess_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDirectAccess *arg1 = (ShaderDirectAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DescriptorType result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDirectAccess_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDirectAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDirectAccess_type_get" "', argument " "1"" of type '" "ShaderDirectAccess *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDirectAccess * >(argp1);
  result = (DescriptorType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_DescriptorType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDirectAccess_descriptorStore_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDirectAccess *arg1 = (ShaderDirectAccess *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDirectAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDirectAccess_descriptorStore_set" "', argument " "1"" of type '" "ShaderDirectAccess *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDirectAccess * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderDirectAccess_descriptorStore_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->descriptorStore = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDirectAccess_descriptorStore_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDirectAccess *arg1 = (ShaderDirectAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDirectAccess_descriptorStore_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDirectAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDirectAccess_descriptorStore_get" "', argument " "1"" of type '" "ShaderDirectAccess *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDirectAccess * >(argp1);
  result = (ResourceId *)& ((arg1)->descriptorStore);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDirectAccess_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDirectAccess *arg1 = (ShaderDirectAccess *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDirectAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDirectAccess_byteOffset_set" "', argument " "1"" of type '" "ShaderDirectAccess *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDirectAccess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderDirectAccess_byteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDirectAccess_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDirectAccess *arg1 = (ShaderDirectAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDirectAccess_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDirectAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDirectAccess_byteOffset_get" "', argument " "1"" of type '" "ShaderDirectAccess *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDirectAccess * >(argp1);
  result = (uint32_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDirectAccess_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDirectAccess *arg1 = (ShaderDirectAccess *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDirectAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDirectAccess_byteSize_set" "', argument " "1"" of type '" "ShaderDirectAccess *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDirectAccess * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderDirectAccess_byteSize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDirectAccess_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDirectAccess *arg1 = (ShaderDirectAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDirectAccess_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDirectAccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDirectAccess_byteSize_get" "', argument " "1"" of type '" "ShaderDirectAccess *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDirectAccess * >(argp1);
  result = (uint32_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderDirectAccess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDirectAccess *arg1 = (ShaderDirectAccess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderDirectAccess",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDirectAccess, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderDirectAccess" "', argument " "1"" of type '" "ShaderDirectAccess *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDirectAccess * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderDirectAccess) /* defines _wrap_delete_ShaderDirectAccess_destructor_closure */

SWIGINTERN PyObject *_wrap_ShaderValue_f32v_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  rdcfixedarray< float,16 > *arg2 = (rdcfixedarray< float,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_f32v_set" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderValue_f32v_set' argument 2 of type 'rdcfixedarray< float,16 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderValue_f32v_set' argument 2 of type 'rdcfixedarray< float,16 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->f32v = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_f32v_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< float,16 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderValue_f32v_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_f32v_get" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  result = (rdcfixedarray< float,16 > *)& ((arg1)->f32v);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_s32v_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  rdcfixedarray< int32_t,16 > *arg2 = (rdcfixedarray< int32_t,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_s32v_set" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderValue_s32v_set' argument 2 of type 'rdcfixedarray< int32_t,16 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderValue_s32v_set' argument 2 of type 'rdcfixedarray< int32_t,16 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->s32v = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_s32v_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< int32_t,16 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderValue_s32v_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_s32v_get" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  result = (rdcfixedarray< int32_t,16 > *)& ((arg1)->s32v);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_u32v_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  rdcfixedarray< uint32_t,16 > *arg2 = (rdcfixedarray< uint32_t,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_u32v_set" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderValue_u32v_set' argument 2 of type 'rdcfixedarray< uint32_t,16 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderValue_u32v_set' argument 2 of type 'rdcfixedarray< uint32_t,16 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->u32v = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_u32v_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint32_t,16 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderValue_u32v_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_u32v_get" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  result = (rdcfixedarray< uint32_t,16 > *)& ((arg1)->u32v);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_f64v_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  rdcfixedarray< double,16 > *arg2 = (rdcfixedarray< double,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_f64v_set" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderValue_f64v_set' argument 2 of type 'rdcfixedarray< double,16 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderValue_f64v_set' argument 2 of type 'rdcfixedarray< double,16 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->f64v = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_f64v_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< double,16 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderValue_f64v_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_f64v_get" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  result = (rdcfixedarray< double,16 > *)& ((arg1)->f64v);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_f16v_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  rdcfixedarray< rdhalf,16 > *arg2 = (rdcfixedarray< rdhalf,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_f16v_set" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderValue_f16v_set' argument 2 of type 'rdcfixedarray< rdhalf,16 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderValue_f16v_set' argument 2 of type 'rdcfixedarray< rdhalf,16 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->f16v = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_f16v_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< rdhalf,16 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderValue_f16v_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_f16v_get" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  result = (rdcfixedarray< rdhalf,16 > *)& ((arg1)->f16v);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_u64v_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  rdcfixedarray< uint64_t,16 > *arg2 = (rdcfixedarray< uint64_t,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_u64v_set" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderValue_u64v_set' argument 2 of type 'rdcfixedarray< uint64_t,16 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderValue_u64v_set' argument 2 of type 'rdcfixedarray< uint64_t,16 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->u64v = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_u64v_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint64_t,16 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderValue_u64v_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_u64v_get" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  result = (rdcfixedarray< uint64_t,16 > *)& ((arg1)->u64v);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_s64v_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  rdcfixedarray< int64_t,16 > *arg2 = (rdcfixedarray< int64_t,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_s64v_set" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderValue_s64v_set' argument 2 of type 'rdcfixedarray< int64_t,16 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderValue_s64v_set' argument 2 of type 'rdcfixedarray< int64_t,16 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->s64v = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_s64v_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< int64_t,16 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderValue_s64v_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_s64v_get" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  result = (rdcfixedarray< int64_t,16 > *)& ((arg1)->s64v);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_u16v_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  rdcfixedarray< uint16_t,16 > *arg2 = (rdcfixedarray< uint16_t,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_u16v_set" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderValue_u16v_set' argument 2 of type 'rdcfixedarray< uint16_t,16 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderValue_u16v_set' argument 2 of type 'rdcfixedarray< uint16_t,16 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->u16v = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_u16v_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint16_t,16 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderValue_u16v_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_u16v_get" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  result = (rdcfixedarray< uint16_t,16 > *)& ((arg1)->u16v);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_s16v_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  rdcfixedarray< int16_t,16 > *arg2 = (rdcfixedarray< int16_t,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_s16v_set" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderValue_s16v_set' argument 2 of type 'rdcfixedarray< int16_t,16 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderValue_s16v_set' argument 2 of type 'rdcfixedarray< int16_t,16 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->s16v = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_s16v_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< int16_t,16 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderValue_s16v_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_s16v_get" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  result = (rdcfixedarray< int16_t,16 > *)& ((arg1)->s16v);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_u8v_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  rdcfixedarray< uint8_t,16 > *arg2 = (rdcfixedarray< uint8_t,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_u8v_set" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderValue_u8v_set' argument 2 of type 'rdcfixedarray< uint8_t,16 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderValue_u8v_set' argument 2 of type 'rdcfixedarray< uint8_t,16 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->u8v = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_u8v_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint8_t,16 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderValue_u8v_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_u8v_get" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  result = (rdcfixedarray< uint8_t,16 > *)& ((arg1)->u8v);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_s8v_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  rdcfixedarray< int8_t,16 > *arg2 = (rdcfixedarray< int8_t,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_s8v_set" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderValue_s8v_set' argument 2 of type 'rdcfixedarray< int8_t,16 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderValue_s8v_set' argument 2 of type 'rdcfixedarray< int8_t,16 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->s8v = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderValue_s8v_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< int8_t,16 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderValue_s8v_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderValue_s8v_get" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  result = (rdcfixedarray< int8_t,16 > *)& ((arg1)->s8v);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int _wrap_new_ShaderValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_ShaderValue",0,0,0)) SWIG_fail;
  result = (ShaderValue *)new ShaderValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderValue, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_delete_ShaderValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderValue *arg1 = (ShaderValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderValue",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderValue" "', argument " "1"" of type '" "ShaderValue *""'"); 
  }
  arg1 = reinterpret_cast< ShaderValue * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderValue) /* defines _wrap_delete_ShaderValue_destructor_closure */

SWIGINTERN int _wrap_new_ShaderVariable__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderVariable *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderVariable *)new ShaderVariable();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderVariable, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderVariable__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderVariable *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderVariable,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderVariable" "', argument " "1"" of type '" "ShaderVariable const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderVariable" "', argument " "1"" of type '" "ShaderVariable const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result = (ShaderVariable *)new ShaderVariable((ShaderVariable const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderVariable, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderVariable__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  rdcstr temp1 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  ShaderVariable *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_ShaderVariable' argument 1 of type 'rdcstr'"); 
    }
  }
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShaderVariable" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ShaderVariable" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ShaderVariable" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ShaderVariable" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  result = (ShaderVariable *)new ShaderVariable((rdcstr const &)*arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderVariable, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderVariable__SWIG_3(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  rdcstr temp1 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  ShaderVariable *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_ShaderVariable' argument 1 of type 'rdcstr'"); 
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShaderVariable" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ShaderVariable" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ShaderVariable" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ShaderVariable" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (ShaderVariable *)new ShaderVariable((rdcstr const &)*arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderVariable, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderVariable__SWIG_4(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  uint32_t arg5 ;
  rdcstr temp1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  ShaderVariable *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_ShaderVariable' argument 1 of type 'rdcstr'"); 
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShaderVariable" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ShaderVariable" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ShaderVariable" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ShaderVariable" "', argument " "5"" of type '" "uint32_t""'");
  } 
  arg5 = static_cast< uint32_t >(val5);
  result = (ShaderVariable *)new ShaderVariable((rdcstr const &)*arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderVariable, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderVariable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderVariable",0,5,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderVariable__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderVariable__SWIG_1(self, argc, argv);
  }
  if (argc == 5) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    return _wrap_new_ShaderVariable__SWIG_4(self, argc, argv);
  }
check_3:
  
  if (argc == 5) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      {
        int res = SWIG_AsVal_int(argv[3], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      {
        int res = SWIG_AsVal_int(argv[4], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_ShaderVariable__SWIG_3(self, argc, argv);
  }
check_4:
  
  if (argc == 5) {
    return _wrap_new_ShaderVariable__SWIG_2(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderVariable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderVariable::ShaderVariable()\n"
    "    ShaderVariable::ShaderVariable(ShaderVariable const &)\n"
    "    ShaderVariable::ShaderVariable(rdcstr const &,float,float,float,float)\n"
    "    ShaderVariable::ShaderVariable(rdcstr const &,int,int,int,int)\n"
    "    ShaderVariable::ShaderVariable(rdcstr const &,uint32_t,uint32_t,uint32_t,uint32_t)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderVariable___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  ShaderVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable___lt__" "', argument " "1"" of type '" "ShaderVariable const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderVariable,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderVariable___lt__" "', argument " "2"" of type '" "ShaderVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderVariable___lt__" "', argument " "2"" of type '" "ShaderVariable const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderVariable * >(argp2);
  result = (bool)((ShaderVariable const *)arg1)->operator <((ShaderVariable const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_name_set" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderVariable_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_name_get" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_rows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_rows_set" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderVariable_rows_set" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  if (arg1) (arg1)->rows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_rows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_rows_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_rows_get" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result = (uint8_t) ((arg1)->rows);
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_columns_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_columns_set" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderVariable_columns_set" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  if (arg1) (arg1)->columns = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_columns_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_columns_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_columns_get" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result = (uint8_t) ((arg1)->columns);
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  VarType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_type_set" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderVariable_type_set" "', argument " "2"" of type '" "VarType""'");
  } 
  arg2 = static_cast< VarType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VarType result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_type_get" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result = (VarType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_VarType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  ShaderVariableFlags arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_flags_set" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderVariable_flags_set" "', argument " "2"" of type '" "ShaderVariableFlags""'");
  } 
  arg2 = static_cast< ShaderVariableFlags >(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderVariableFlags result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_flags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_flags_get" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result = (ShaderVariableFlags) ((arg1)->flags);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderVariableFlags->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  ShaderValue *arg2 = (ShaderValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_value_set" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderVariable_value_set" "', argument " "2"" of type '" "ShaderValue *""'"); 
  }
  arg2 = reinterpret_cast< ShaderValue * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_value_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_value_get" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result = (ShaderValue *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderValue, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_members_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  rdcarray< ShaderVariable > *arg2 = (rdcarray< ShaderVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_members_set" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderVariable_members_set' argument 2 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderVariable_members_set' argument 2 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->members = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_members_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderVariable > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_members_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_members_get" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result = (rdcarray< ShaderVariable > *)& ((arg1)->members);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderVariable_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_RowMajor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_RowMajor",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_RowMajor" "', argument " "1"" of type '" "ShaderVariable const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result = (bool)((ShaderVariable const *)arg1)->RowMajor();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_ColMajor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_ColMajor",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_ColMajor" "', argument " "1"" of type '" "ShaderVariable const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result = (bool)((ShaderVariable const *)arg1)->ColMajor();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_SetTypelessPointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_SetTypelessPointer" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderVariable_SetTypelessPointer" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  (arg1)->SetTypelessPointer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_SetTypedPointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  uint64_t arg2 ;
  ResourceId arg3 ;
  uint32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_SetTypedPointer",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_SetTypedPointer" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderVariable_SetTypedPointer" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShaderVariable_SetTypedPointer" "', argument " "3"" of type '" "ResourceId""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderVariable_SetTypedPointer" "', argument " "3"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ShaderVariable_SetTypedPointer" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  (arg1)->SetTypedPointer(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_GetPointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PointerVal result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_GetPointer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_GetPointer" "', argument " "1"" of type '" "ShaderVariable const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result = ((ShaderVariable const *)arg1)->GetPointer();
  resultobj = SWIG_NewPointerObj((new PointerVal(static_cast< const PointerVal& >(result))), SWIGTYPE_p_PointerVal, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_SetBindIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  ShaderBindIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_SetBindIndex" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderBindIndex,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderVariable_SetBindIndex" "', argument " "2"" of type '" "ShaderBindIndex const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderVariable_SetBindIndex" "', argument " "2"" of type '" "ShaderBindIndex const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderBindIndex * >(argp2);
  (arg1)->SetBindIndex((ShaderBindIndex const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_GetBindIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderBindIndex result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_GetBindIndex",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_GetBindIndex" "', argument " "1"" of type '" "ShaderVariable const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result = ((ShaderVariable const *)arg1)->GetBindIndex();
  resultobj = SWIG_NewPointerObj((new ShaderBindIndex(static_cast< const ShaderBindIndex& >(result))), SWIGTYPE_p_ShaderBindIndex, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_SetDirectAccess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  ShaderDirectAccess *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_SetDirectAccess" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderDirectAccess,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderVariable_SetDirectAccess" "', argument " "2"" of type '" "ShaderDirectAccess const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderVariable_SetDirectAccess" "', argument " "2"" of type '" "ShaderDirectAccess const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderDirectAccess * >(argp2);
  (arg1)->SetDirectAccess((ShaderDirectAccess const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_GetDirectAccess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderDirectAccess result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_GetDirectAccess",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_GetDirectAccess" "', argument " "1"" of type '" "ShaderVariable const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result = ((ShaderVariable const *)arg1)->GetDirectAccess();
  resultobj = SWIG_NewPointerObj((new ShaderDirectAccess(static_cast< const ShaderDirectAccess& >(result))), SWIGTYPE_p_ShaderDirectAccess, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable_IsDirectAccess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariable_IsDirectAccess",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable_IsDirectAccess" "', argument " "1"" of type '" "ShaderVariable const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  result = (bool)((ShaderVariable const *)arg1)->IsDirectAccess();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable___eq__" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderVariable___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariable___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariable___ne__" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderVariable___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderVariable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariable *arg1 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderVariable",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderVariable" "', argument " "1"" of type '" "ShaderVariable *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariable * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderVariable) /* defines _wrap_delete_ShaderVariable_destructor_closure */

SWIGINTERN int _wrap_new_DebugVariableReference__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  DebugVariableReference *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (DebugVariableReference *)new DebugVariableReference();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DebugVariableReference, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DebugVariableReference__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DebugVariableReference *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DebugVariableReference *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DebugVariableReference,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DebugVariableReference" "', argument " "1"" of type '" "DebugVariableReference const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DebugVariableReference" "', argument " "1"" of type '" "DebugVariableReference const &""'"); 
  }
  arg1 = reinterpret_cast< DebugVariableReference * >(argp1);
  result = (DebugVariableReference *)new DebugVariableReference((DebugVariableReference const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DebugVariableReference, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DebugVariableReference__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DebugVariableType arg1 ;
  rdcstr arg2 ;
  uint32_t arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  rdcstr temp2 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  DebugVariableReference *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DebugVariableReference" "', argument " "1"" of type '" "DebugVariableType""'");
  } 
  arg1 = static_cast< DebugVariableType >(val1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_DebugVariableReference' argument 2 of type 'rdcstr'"); 
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DebugVariableReference" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  result = (DebugVariableReference *)new DebugVariableReference(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DebugVariableReference, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DebugVariableReference__SWIG_3(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DebugVariableType arg1 ;
  rdcstr arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  rdcstr temp2 ;
  DebugVariableReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DebugVariableReference" "', argument " "1"" of type '" "DebugVariableType""'");
  } 
  arg1 = static_cast< DebugVariableType >(val1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_DebugVariableReference' argument 2 of type 'rdcstr'"); 
    }
  }
  result = (DebugVariableReference *)new DebugVariableReference(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DebugVariableReference, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_DebugVariableReference(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_DebugVariableReference",0,3,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DebugVariableReference__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_DebugVariableReference__SWIG_1(self, argc, argv);
  }
  if (argc == 2) {
    return _wrap_new_DebugVariableReference__SWIG_3(self, argc, argv);
  }
  if (argc == 3) {
    return _wrap_new_DebugVariableReference__SWIG_2(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DebugVariableReference'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DebugVariableReference::DebugVariableReference()\n"
    "    DebugVariableReference::DebugVariableReference(DebugVariableReference const &)\n"
    "    DebugVariableReference::DebugVariableReference(DebugVariableType,rdcstr,uint32_t)\n"
    "    DebugVariableReference::DebugVariableReference(DebugVariableType,rdcstr)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_DebugVariableReference___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugVariableReference *arg1 = (DebugVariableReference *) 0 ;
  DebugVariableReference *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugVariableReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugVariableReference___lt__" "', argument " "1"" of type '" "DebugVariableReference const *""'"); 
  }
  arg1 = reinterpret_cast< DebugVariableReference * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_DebugVariableReference,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DebugVariableReference___lt__" "', argument " "2"" of type '" "DebugVariableReference const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DebugVariableReference___lt__" "', argument " "2"" of type '" "DebugVariableReference const &""'"); 
  }
  arg2 = reinterpret_cast< DebugVariableReference * >(argp2);
  result = (bool)((DebugVariableReference const *)arg1)->operator <((DebugVariableReference const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugVariableReference_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugVariableReference *arg1 = (DebugVariableReference *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugVariableReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugVariableReference_name_set" "', argument " "1"" of type '" "DebugVariableReference *""'"); 
  }
  arg1 = reinterpret_cast< DebugVariableReference * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'DebugVariableReference_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugVariableReference_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugVariableReference *arg1 = (DebugVariableReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"DebugVariableReference_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugVariableReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugVariableReference_name_get" "', argument " "1"" of type '" "DebugVariableReference *""'"); 
  }
  arg1 = reinterpret_cast< DebugVariableReference * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugVariableReference_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugVariableReference *arg1 = (DebugVariableReference *) 0 ;
  DebugVariableType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugVariableReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugVariableReference_type_set" "', argument " "1"" of type '" "DebugVariableReference *""'"); 
  }
  arg1 = reinterpret_cast< DebugVariableReference * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DebugVariableReference_type_set" "', argument " "2"" of type '" "DebugVariableType""'");
  } 
  arg2 = static_cast< DebugVariableType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugVariableReference_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugVariableReference *arg1 = (DebugVariableReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DebugVariableType result;
  
  if (!SWIG_Python_UnpackTuple(args,"DebugVariableReference_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugVariableReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugVariableReference_type_get" "', argument " "1"" of type '" "DebugVariableReference *""'"); 
  }
  arg1 = reinterpret_cast< DebugVariableReference * >(argp1);
  result = (DebugVariableType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_DebugVariableType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugVariableReference_component_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugVariableReference *arg1 = (DebugVariableReference *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugVariableReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugVariableReference_component_set" "', argument " "1"" of type '" "DebugVariableReference *""'"); 
  }
  arg1 = reinterpret_cast< DebugVariableReference * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DebugVariableReference_component_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->component = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugVariableReference_component_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugVariableReference *arg1 = (DebugVariableReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"DebugVariableReference_component_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugVariableReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugVariableReference_component_get" "', argument " "1"" of type '" "DebugVariableReference *""'"); 
  }
  arg1 = reinterpret_cast< DebugVariableReference * >(argp1);
  result = (uint32_t) ((arg1)->component);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugVariableReference___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugVariableReference *arg1 = (DebugVariableReference *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugVariableReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugVariableReference___eq__" "', argument " "1"" of type '" "DebugVariableReference *""'"); 
  }
  arg1 = reinterpret_cast< DebugVariableReference * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)DebugVariableReference___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DebugVariableReference___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugVariableReference *arg1 = (DebugVariableReference *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugVariableReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DebugVariableReference___ne__" "', argument " "1"" of type '" "DebugVariableReference *""'"); 
  }
  arg1 = reinterpret_cast< DebugVariableReference * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)DebugVariableReference___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DebugVariableReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DebugVariableReference *arg1 = (DebugVariableReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_DebugVariableReference",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugVariableReference, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DebugVariableReference" "', argument " "1"" of type '" "DebugVariableReference *""'"); 
  }
  arg1 = reinterpret_cast< DebugVariableReference * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_DebugVariableReference) /* defines _wrap_delete_DebugVariableReference_destructor_closure */

SWIGINTERN int _wrap_new_SourceVariableMapping__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SourceVariableMapping *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SourceVariableMapping *)new SourceVariableMapping();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SourceVariableMapping, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_SourceVariableMapping__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SourceVariableMapping *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SourceVariableMapping,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SourceVariableMapping" "', argument " "1"" of type '" "SourceVariableMapping const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SourceVariableMapping" "', argument " "1"" of type '" "SourceVariableMapping const &""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  result = (SourceVariableMapping *)new SourceVariableMapping((SourceVariableMapping const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SourceVariableMapping, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_SourceVariableMapping(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SourceVariableMapping",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SourceVariableMapping__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_SourceVariableMapping__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SourceVariableMapping'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SourceVariableMapping::SourceVariableMapping()\n"
    "    SourceVariableMapping::SourceVariableMapping(SourceVariableMapping const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  SourceVariableMapping *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping___lt__" "', argument " "1"" of type '" "SourceVariableMapping const *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_SourceVariableMapping,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SourceVariableMapping___lt__" "', argument " "2"" of type '" "SourceVariableMapping const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SourceVariableMapping___lt__" "', argument " "2"" of type '" "SourceVariableMapping const &""'"); 
  }
  arg2 = reinterpret_cast< SourceVariableMapping * >(argp2);
  result = (bool)((SourceVariableMapping const *)arg1)->operator <((SourceVariableMapping const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_name_set" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SourceVariableMapping_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"SourceVariableMapping_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_name_get" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  VarType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_type_set" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SourceVariableMapping_type_set" "', argument " "2"" of type '" "VarType""'");
  } 
  arg2 = static_cast< VarType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VarType result;
  
  if (!SWIG_Python_UnpackTuple(args,"SourceVariableMapping_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_type_get" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  result = (VarType) ((arg1)->type);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_VarType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_undefinedValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_undefinedValue_set" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SourceVariableMapping_undefinedValue_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->undefinedValue = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_undefinedValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"SourceVariableMapping_undefinedValue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_undefinedValue_get" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  result = (bool) ((arg1)->undefinedValue);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_rows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_rows_set" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SourceVariableMapping_rows_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->rows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_rows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SourceVariableMapping_rows_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_rows_get" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  result = (uint32_t) ((arg1)->rows);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_columns_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_columns_set" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SourceVariableMapping_columns_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->columns = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_columns_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SourceVariableMapping_columns_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_columns_get" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  result = (uint32_t) ((arg1)->columns);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_offset_set" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SourceVariableMapping_offset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SourceVariableMapping_offset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_offset_get" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  result = (uint32_t) ((arg1)->offset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_signatureIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_signatureIndex_set" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SourceVariableMapping_signatureIndex_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->signatureIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_signatureIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SourceVariableMapping_signatureIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_signatureIndex_get" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  result = (int32_t) ((arg1)->signatureIndex);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_variables_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  rdcarray< DebugVariableReference > *arg2 = (rdcarray< DebugVariableReference > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_variables_set" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'SourceVariableMapping_variables_set' argument 2 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'SourceVariableMapping_variables_set' argument 2 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->variables = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping_variables_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< DebugVariableReference > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"SourceVariableMapping_variables_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping_variables_get" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  result = (rdcarray< DebugVariableReference > *)& ((arg1)->variables);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_DebugVariableReference_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping___eq__" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)SourceVariableMapping___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SourceVariableMapping___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SourceVariableMapping___ne__" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)SourceVariableMapping___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SourceVariableMapping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SourceVariableMapping *arg1 = (SourceVariableMapping *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_SourceVariableMapping",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SourceVariableMapping, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SourceVariableMapping" "', argument " "1"" of type '" "SourceVariableMapping *""'"); 
  }
  arg1 = reinterpret_cast< SourceVariableMapping * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_SourceVariableMapping) /* defines _wrap_delete_SourceVariableMapping_destructor_closure */

SWIGINTERN int _wrap_new_LineColumnInfo__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  LineColumnInfo *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (LineColumnInfo *)new LineColumnInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LineColumnInfo, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_LineColumnInfo__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  LineColumnInfo *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_LineColumnInfo,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LineColumnInfo" "', argument " "1"" of type '" "LineColumnInfo const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LineColumnInfo" "', argument " "1"" of type '" "LineColumnInfo const &""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  result = (LineColumnInfo *)new LineColumnInfo((LineColumnInfo const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LineColumnInfo, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_LineColumnInfo(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_LineColumnInfo",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_LineColumnInfo__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_LineColumnInfo__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LineColumnInfo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LineColumnInfo::LineColumnInfo()\n"
    "    LineColumnInfo::LineColumnInfo(LineColumnInfo const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  LineColumnInfo *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo___lt__" "', argument " "1"" of type '" "LineColumnInfo const *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_LineColumnInfo,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LineColumnInfo___lt__" "', argument " "2"" of type '" "LineColumnInfo const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LineColumnInfo___lt__" "', argument " "2"" of type '" "LineColumnInfo const &""'"); 
  }
  arg2 = reinterpret_cast< LineColumnInfo * >(argp2);
  result = (bool)((LineColumnInfo const *)arg1)->operator <((LineColumnInfo const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo_SourceEqual(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  LineColumnInfo *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo_SourceEqual" "', argument " "1"" of type '" "LineColumnInfo const *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_LineColumnInfo,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LineColumnInfo_SourceEqual" "', argument " "2"" of type '" "LineColumnInfo const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LineColumnInfo_SourceEqual" "', argument " "2"" of type '" "LineColumnInfo const &""'"); 
  }
  arg2 = reinterpret_cast< LineColumnInfo * >(argp2);
  result = (bool)((LineColumnInfo const *)arg1)->SourceEqual((LineColumnInfo const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo_disassemblyLine_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo_disassemblyLine_set" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LineColumnInfo_disassemblyLine_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->disassemblyLine = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo_disassemblyLine_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"LineColumnInfo_disassemblyLine_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo_disassemblyLine_get" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  result = (uint32_t) ((arg1)->disassemblyLine);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo_fileIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo_fileIndex_set" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LineColumnInfo_fileIndex_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->fileIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo_fileIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"LineColumnInfo_fileIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo_fileIndex_get" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  result = (int32_t) ((arg1)->fileIndex);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo_lineStart_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo_lineStart_set" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LineColumnInfo_lineStart_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->lineStart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo_lineStart_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"LineColumnInfo_lineStart_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo_lineStart_get" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  result = (uint32_t) ((arg1)->lineStart);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo_lineEnd_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo_lineEnd_set" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LineColumnInfo_lineEnd_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->lineEnd = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo_lineEnd_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"LineColumnInfo_lineEnd_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo_lineEnd_get" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  result = (uint32_t) ((arg1)->lineEnd);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo_colStart_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo_colStart_set" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LineColumnInfo_colStart_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->colStart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo_colStart_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"LineColumnInfo_colStart_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo_colStart_get" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  result = (uint32_t) ((arg1)->colStart);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo_colEnd_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo_colEnd_set" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LineColumnInfo_colEnd_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->colEnd = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo_colEnd_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"LineColumnInfo_colEnd_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo_colEnd_get" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  result = (uint32_t) ((arg1)->colEnd);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo___eq__" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)LineColumnInfo___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LineColumnInfo___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LineColumnInfo___ne__" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)LineColumnInfo___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LineColumnInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LineColumnInfo *arg1 = (LineColumnInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_LineColumnInfo",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_LineColumnInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LineColumnInfo" "', argument " "1"" of type '" "LineColumnInfo *""'"); 
  }
  arg1 = reinterpret_cast< LineColumnInfo * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_LineColumnInfo) /* defines _wrap_delete_LineColumnInfo_destructor_closure */

SWIGINTERN int _wrap_new_InstructionSourceInfo__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  InstructionSourceInfo *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (InstructionSourceInfo *)new InstructionSourceInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InstructionSourceInfo, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_InstructionSourceInfo__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InstructionSourceInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InstructionSourceInfo *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_InstructionSourceInfo,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstructionSourceInfo" "', argument " "1"" of type '" "InstructionSourceInfo const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InstructionSourceInfo" "', argument " "1"" of type '" "InstructionSourceInfo const &""'"); 
  }
  arg1 = reinterpret_cast< InstructionSourceInfo * >(argp1);
  result = (InstructionSourceInfo *)new InstructionSourceInfo((InstructionSourceInfo const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InstructionSourceInfo, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_InstructionSourceInfo(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_InstructionSourceInfo",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_InstructionSourceInfo__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_InstructionSourceInfo__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InstructionSourceInfo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InstructionSourceInfo::InstructionSourceInfo()\n"
    "    InstructionSourceInfo::InstructionSourceInfo(InstructionSourceInfo const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_InstructionSourceInfo___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InstructionSourceInfo *arg1 = (InstructionSourceInfo *) 0 ;
  InstructionSourceInfo *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_InstructionSourceInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstructionSourceInfo___eq__" "', argument " "1"" of type '" "InstructionSourceInfo const *""'"); 
  }
  arg1 = reinterpret_cast< InstructionSourceInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_InstructionSourceInfo,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstructionSourceInfo___eq__" "', argument " "2"" of type '" "InstructionSourceInfo const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InstructionSourceInfo___eq__" "', argument " "2"" of type '" "InstructionSourceInfo const &""'"); 
  }
  arg2 = reinterpret_cast< InstructionSourceInfo * >(argp2);
  result = (bool)((InstructionSourceInfo const *)arg1)->operator ==((InstructionSourceInfo const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstructionSourceInfo___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InstructionSourceInfo *arg1 = (InstructionSourceInfo *) 0 ;
  InstructionSourceInfo *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_InstructionSourceInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstructionSourceInfo___lt__" "', argument " "1"" of type '" "InstructionSourceInfo const *""'"); 
  }
  arg1 = reinterpret_cast< InstructionSourceInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_InstructionSourceInfo,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstructionSourceInfo___lt__" "', argument " "2"" of type '" "InstructionSourceInfo const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InstructionSourceInfo___lt__" "', argument " "2"" of type '" "InstructionSourceInfo const &""'"); 
  }
  arg2 = reinterpret_cast< InstructionSourceInfo * >(argp2);
  result = (bool)((InstructionSourceInfo const *)arg1)->operator <((InstructionSourceInfo const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstructionSourceInfo_instruction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InstructionSourceInfo *arg1 = (InstructionSourceInfo *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_InstructionSourceInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstructionSourceInfo_instruction_set" "', argument " "1"" of type '" "InstructionSourceInfo *""'"); 
  }
  arg1 = reinterpret_cast< InstructionSourceInfo * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstructionSourceInfo_instruction_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->instruction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstructionSourceInfo_instruction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InstructionSourceInfo *arg1 = (InstructionSourceInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"InstructionSourceInfo_instruction_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_InstructionSourceInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstructionSourceInfo_instruction_get" "', argument " "1"" of type '" "InstructionSourceInfo *""'"); 
  }
  arg1 = reinterpret_cast< InstructionSourceInfo * >(argp1);
  result = (uint32_t) ((arg1)->instruction);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstructionSourceInfo_lineInfo_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InstructionSourceInfo *arg1 = (InstructionSourceInfo *) 0 ;
  LineColumnInfo *arg2 = (LineColumnInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_InstructionSourceInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstructionSourceInfo_lineInfo_set" "', argument " "1"" of type '" "InstructionSourceInfo *""'"); 
  }
  arg1 = reinterpret_cast< InstructionSourceInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstructionSourceInfo_lineInfo_set" "', argument " "2"" of type '" "LineColumnInfo *""'"); 
  }
  arg2 = reinterpret_cast< LineColumnInfo * >(argp2);
  if (arg1) (arg1)->lineInfo = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstructionSourceInfo_lineInfo_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InstructionSourceInfo *arg1 = (InstructionSourceInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  LineColumnInfo *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"InstructionSourceInfo_lineInfo_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_InstructionSourceInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstructionSourceInfo_lineInfo_get" "', argument " "1"" of type '" "InstructionSourceInfo *""'"); 
  }
  arg1 = reinterpret_cast< InstructionSourceInfo * >(argp1);
  result = (LineColumnInfo *)& ((arg1)->lineInfo);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstructionSourceInfo_sourceVars_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InstructionSourceInfo *arg1 = (InstructionSourceInfo *) 0 ;
  rdcarray< SourceVariableMapping > *arg2 = (rdcarray< SourceVariableMapping > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_InstructionSourceInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstructionSourceInfo_sourceVars_set" "', argument " "1"" of type '" "InstructionSourceInfo *""'"); 
  }
  arg1 = reinterpret_cast< InstructionSourceInfo * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'InstructionSourceInfo_sourceVars_set' argument 2 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'InstructionSourceInfo_sourceVars_set' argument 2 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->sourceVars = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstructionSourceInfo_sourceVars_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InstructionSourceInfo *arg1 = (InstructionSourceInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< SourceVariableMapping > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"InstructionSourceInfo_sourceVars_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_InstructionSourceInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstructionSourceInfo_sourceVars_get" "', argument " "1"" of type '" "InstructionSourceInfo *""'"); 
  }
  arg1 = reinterpret_cast< InstructionSourceInfo * >(argp1);
  result = (rdcarray< SourceVariableMapping > *)& ((arg1)->sourceVars);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_SourceVariableMapping_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InstructionSourceInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InstructionSourceInfo *arg1 = (InstructionSourceInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_InstructionSourceInfo",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_InstructionSourceInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstructionSourceInfo" "', argument " "1"" of type '" "InstructionSourceInfo *""'"); 
  }
  arg1 = reinterpret_cast< InstructionSourceInfo * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_InstructionSourceInfo) /* defines _wrap_delete_InstructionSourceInfo_destructor_closure */

SWIGINTERN int _wrap_new_ShaderVariableChange__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderVariableChange *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderVariableChange *)new ShaderVariableChange();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderVariableChange, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderVariableChange__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderVariableChange *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderVariableChange *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderVariableChange,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderVariableChange" "', argument " "1"" of type '" "ShaderVariableChange const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderVariableChange" "', argument " "1"" of type '" "ShaderVariableChange const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariableChange * >(argp1);
  result = (ShaderVariableChange *)new ShaderVariableChange((ShaderVariableChange const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderVariableChange, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderVariableChange(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderVariableChange",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderVariableChange__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderVariableChange__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderVariableChange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderVariableChange::ShaderVariableChange()\n"
    "    ShaderVariableChange::ShaderVariableChange(ShaderVariableChange const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderVariableChange___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariableChange *arg1 = (ShaderVariableChange *) 0 ;
  ShaderVariableChange *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariableChange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariableChange___eq__" "', argument " "1"" of type '" "ShaderVariableChange const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariableChange * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderVariableChange,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderVariableChange___eq__" "', argument " "2"" of type '" "ShaderVariableChange const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderVariableChange___eq__" "', argument " "2"" of type '" "ShaderVariableChange const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderVariableChange * >(argp2);
  result = (bool)((ShaderVariableChange const *)arg1)->operator ==((ShaderVariableChange const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariableChange___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariableChange *arg1 = (ShaderVariableChange *) 0 ;
  ShaderVariableChange *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariableChange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariableChange___lt__" "', argument " "1"" of type '" "ShaderVariableChange const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariableChange * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderVariableChange,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderVariableChange___lt__" "', argument " "2"" of type '" "ShaderVariableChange const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderVariableChange___lt__" "', argument " "2"" of type '" "ShaderVariableChange const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderVariableChange * >(argp2);
  result = (bool)((ShaderVariableChange const *)arg1)->operator <((ShaderVariableChange const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariableChange_before_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariableChange *arg1 = (ShaderVariableChange *) 0 ;
  ShaderVariable *arg2 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariableChange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariableChange_before_set" "', argument " "1"" of type '" "ShaderVariableChange *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariableChange * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderVariableChange_before_set" "', argument " "2"" of type '" "ShaderVariable *""'"); 
  }
  arg2 = reinterpret_cast< ShaderVariable * >(argp2);
  if (arg1) (arg1)->before = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariableChange_before_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariableChange *arg1 = (ShaderVariableChange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderVariable *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariableChange_before_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariableChange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariableChange_before_get" "', argument " "1"" of type '" "ShaderVariableChange *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariableChange * >(argp1);
  result = (ShaderVariable *)& ((arg1)->before);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariableChange_after_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariableChange *arg1 = (ShaderVariableChange *) 0 ;
  ShaderVariable *arg2 = (ShaderVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariableChange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariableChange_after_set" "', argument " "1"" of type '" "ShaderVariableChange *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariableChange * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderVariableChange_after_set" "', argument " "2"" of type '" "ShaderVariable *""'"); 
  }
  arg2 = reinterpret_cast< ShaderVariable * >(argp2);
  if (arg1) (arg1)->after = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderVariableChange_after_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariableChange *arg1 = (ShaderVariableChange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderVariable *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderVariableChange_after_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariableChange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderVariableChange_after_get" "', argument " "1"" of type '" "ShaderVariableChange *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariableChange * >(argp1);
  result = (ShaderVariable *)& ((arg1)->after);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderVariable, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderVariableChange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderVariableChange *arg1 = (ShaderVariableChange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderVariableChange",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderVariableChange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderVariableChange" "', argument " "1"" of type '" "ShaderVariableChange *""'"); 
  }
  arg1 = reinterpret_cast< ShaderVariableChange * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderVariableChange) /* defines _wrap_delete_ShaderVariableChange_destructor_closure */

SWIGINTERN int _wrap_new_ShaderDebugState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderDebugState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderDebugState *)new ShaderDebugState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDebugState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderDebugState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderDebugState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderDebugState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderDebugState" "', argument " "1"" of type '" "ShaderDebugState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderDebugState" "', argument " "1"" of type '" "ShaderDebugState const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  result = (ShaderDebugState *)new ShaderDebugState((ShaderDebugState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDebugState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderDebugState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderDebugState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderDebugState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderDebugState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderDebugState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderDebugState::ShaderDebugState()\n"
    "    ShaderDebugState::ShaderDebugState(ShaderDebugState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderDebugState___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  ShaderDebugState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugState___lt__" "', argument " "1"" of type '" "ShaderDebugState const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderDebugState,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderDebugState___lt__" "', argument " "2"" of type '" "ShaderDebugState const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderDebugState___lt__" "', argument " "2"" of type '" "ShaderDebugState const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderDebugState * >(argp2);
  result = (bool)((ShaderDebugState const *)arg1)->operator <((ShaderDebugState const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugState_nextInstruction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugState_nextInstruction_set" "', argument " "1"" of type '" "ShaderDebugState *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderDebugState_nextInstruction_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->nextInstruction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugState_nextInstruction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugState_nextInstruction_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugState_nextInstruction_get" "', argument " "1"" of type '" "ShaderDebugState *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  result = (uint32_t) ((arg1)->nextInstruction);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugState_stepIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugState_stepIndex_set" "', argument " "1"" of type '" "ShaderDebugState *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderDebugState_stepIndex_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->stepIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugState_stepIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugState_stepIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugState_stepIndex_get" "', argument " "1"" of type '" "ShaderDebugState *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  result = (uint32_t) ((arg1)->stepIndex);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugState_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  ShaderEvents arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugState_flags_set" "', argument " "1"" of type '" "ShaderDebugState *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderDebugState_flags_set" "', argument " "2"" of type '" "ShaderEvents""'");
  } 
  arg2 = static_cast< ShaderEvents >(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugState_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderEvents result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugState_flags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugState_flags_get" "', argument " "1"" of type '" "ShaderDebugState *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  result = (ShaderEvents) ((arg1)->flags);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderEvents->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugState_changes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  rdcarray< ShaderVariableChange > *arg2 = (rdcarray< ShaderVariableChange > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugState_changes_set" "', argument " "1"" of type '" "ShaderDebugState *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderDebugState_changes_set' argument 2 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderDebugState_changes_set' argument 2 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->changes = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugState_changes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderVariableChange > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugState_changes_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugState_changes_get" "', argument " "1"" of type '" "ShaderDebugState *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  result = (rdcarray< ShaderVariableChange > *)& ((arg1)->changes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderVariableChange_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugState_callstack_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  rdcarray< rdcstr > *arg2 = (rdcarray< rdcstr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugState_callstack_set" "', argument " "1"" of type '" "ShaderDebugState *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderDebugState_callstack_set' argument 2 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderDebugState_callstack_set' argument 2 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->callstack = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugState_callstack_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< rdcstr > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugState_callstack_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugState_callstack_get" "', argument " "1"" of type '" "ShaderDebugState *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  result = (rdcarray< rdcstr > *)& ((arg1)->callstack);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_rdcstr_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugState___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugState___eq__" "', argument " "1"" of type '" "ShaderDebugState *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderDebugState___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugState___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugState___ne__" "', argument " "1"" of type '" "ShaderDebugState *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderDebugState___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderDebugState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugState *arg1 = (ShaderDebugState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderDebugState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderDebugState" "', argument " "1"" of type '" "ShaderDebugState *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderDebugState) /* defines _wrap_delete_ShaderDebugState_destructor_closure */

SWIGINTERN PyObject *_wrap_delete_ShaderDebugger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugger *arg1 = (ShaderDebugger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderDebugger",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugger, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderDebugger" "', argument " "1"" of type '" "ShaderDebugger *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugger * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderDebugger) /* defines _wrap_delete_ShaderDebugger_destructor_closure */

SWIGINTERN int _wrap_new_ShaderDebugTrace__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderDebugTrace *)new ShaderDebugTrace();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDebugTrace, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderDebugTrace__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderDebugTrace *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderDebugTrace,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderDebugTrace" "', argument " "1"" of type '" "ShaderDebugTrace const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderDebugTrace" "', argument " "1"" of type '" "ShaderDebugTrace const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  result = (ShaderDebugTrace *)new ShaderDebugTrace((ShaderDebugTrace const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDebugTrace, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderDebugTrace(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderDebugTrace",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderDebugTrace__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderDebugTrace__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderDebugTrace'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderDebugTrace::ShaderDebugTrace()\n"
    "    ShaderDebugTrace::ShaderDebugTrace(ShaderDebugTrace const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_stage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_stage_set" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderDebugTrace_stage_set" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  if (arg1) (arg1)->stage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_stage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStage result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugTrace_stage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_stage_get" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  result = (ShaderStage) ((arg1)->stage);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_inputs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  rdcarray< ShaderVariable > *arg2 = (rdcarray< ShaderVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_inputs_set" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderDebugTrace_inputs_set' argument 2 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderDebugTrace_inputs_set' argument 2 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->inputs = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_inputs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderVariable > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugTrace_inputs_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_inputs_get" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  result = (rdcarray< ShaderVariable > *)& ((arg1)->inputs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderVariable_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_constantBlocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  rdcarray< ShaderVariable > *arg2 = (rdcarray< ShaderVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_constantBlocks_set" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderDebugTrace_constantBlocks_set' argument 2 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderDebugTrace_constantBlocks_set' argument 2 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->constantBlocks = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_constantBlocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderVariable > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugTrace_constantBlocks_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_constantBlocks_get" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  result = (rdcarray< ShaderVariable > *)& ((arg1)->constantBlocks);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderVariable_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_readOnlyResources_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  rdcarray< ShaderVariable > *arg2 = (rdcarray< ShaderVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_readOnlyResources_set" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderDebugTrace_readOnlyResources_set' argument 2 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderDebugTrace_readOnlyResources_set' argument 2 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->readOnlyResources = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_readOnlyResources_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderVariable > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugTrace_readOnlyResources_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_readOnlyResources_get" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  result = (rdcarray< ShaderVariable > *)& ((arg1)->readOnlyResources);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderVariable_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_readWriteResources_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  rdcarray< ShaderVariable > *arg2 = (rdcarray< ShaderVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_readWriteResources_set" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderDebugTrace_readWriteResources_set' argument 2 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderDebugTrace_readWriteResources_set' argument 2 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->readWriteResources = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_readWriteResources_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderVariable > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugTrace_readWriteResources_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_readWriteResources_get" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  result = (rdcarray< ShaderVariable > *)& ((arg1)->readWriteResources);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderVariable_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_samplers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  rdcarray< ShaderVariable > *arg2 = (rdcarray< ShaderVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_samplers_set" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderDebugTrace_samplers_set' argument 2 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderDebugTrace_samplers_set' argument 2 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->samplers = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_samplers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderVariable > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugTrace_samplers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_samplers_get" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  result = (rdcarray< ShaderVariable > *)& ((arg1)->samplers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderVariable_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_sourceVars_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  rdcarray< SourceVariableMapping > *arg2 = (rdcarray< SourceVariableMapping > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_sourceVars_set" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderDebugTrace_sourceVars_set' argument 2 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderDebugTrace_sourceVars_set' argument 2 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->sourceVars = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_sourceVars_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< SourceVariableMapping > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugTrace_sourceVars_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_sourceVars_get" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  result = (rdcarray< SourceVariableMapping > *)& ((arg1)->sourceVars);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_SourceVariableMapping_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_debugger_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  ShaderDebugger *arg2 = (ShaderDebugger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_debugger_set" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderDebugger, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderDebugTrace_debugger_set" "', argument " "2"" of type '" "ShaderDebugger *""'"); 
  }
  arg2 = reinterpret_cast< ShaderDebugger * >(argp2);
  if (arg1) (arg1)->debugger = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_debugger_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderDebugger *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugTrace_debugger_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_debugger_get" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  result = (ShaderDebugger *) ((arg1)->debugger);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDebugger, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_instInfo_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  rdcarray< InstructionSourceInfo > *arg2 = (rdcarray< InstructionSourceInfo > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_instInfo_set" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderDebugTrace_instInfo_set' argument 2 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderDebugTrace_instInfo_set' argument 2 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->instInfo = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugTrace_instInfo_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< InstructionSourceInfo > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugTrace_instInfo_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugTrace_instInfo_get" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  result = (rdcarray< InstructionSourceInfo > *)& ((arg1)->instInfo);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_InstructionSourceInfo_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderDebugTrace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugTrace *arg1 = (ShaderDebugTrace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderDebugTrace",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugTrace, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderDebugTrace" "', argument " "1"" of type '" "ShaderDebugTrace *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugTrace * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderDebugTrace) /* defines _wrap_delete_ShaderDebugTrace_destructor_closure */

SWIGINTERN int _wrap_new_SigParameter__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SigParameter *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SigParameter *)new SigParameter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SigParameter, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_SigParameter__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SigParameter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SigParameter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SigParameter" "', argument " "1"" of type '" "SigParameter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SigParameter" "', argument " "1"" of type '" "SigParameter const &""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result = (SigParameter *)new SigParameter((SigParameter const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SigParameter, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_SigParameter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_SigParameter",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SigParameter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_SigParameter__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SigParameter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SigParameter::SigParameter()\n"
    "    SigParameter::SigParameter(SigParameter const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_SigParameter___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  SigParameter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter___lt__" "', argument " "1"" of type '" "SigParameter const *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_SigParameter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigParameter___lt__" "', argument " "2"" of type '" "SigParameter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigParameter___lt__" "', argument " "2"" of type '" "SigParameter const &""'"); 
  }
  arg2 = reinterpret_cast< SigParameter * >(argp2);
  result = (bool)((SigParameter const *)arg1)->operator <((SigParameter const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_varName_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_varName_set" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SigParameter_varName_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->varName = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_varName_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"SigParameter_varName_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_varName_get" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result =  ((arg1)->varName);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_semanticName_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_semanticName_set" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SigParameter_semanticName_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->semanticName = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_semanticName_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"SigParameter_semanticName_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_semanticName_get" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result =  ((arg1)->semanticName);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_semanticIdxName_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_semanticIdxName_set" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'SigParameter_semanticIdxName_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->semanticIdxName = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_semanticIdxName_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"SigParameter_semanticIdxName_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_semanticIdxName_get" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result =  ((arg1)->semanticIdxName);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_semanticIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  uint16_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_semanticIndex_set" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigParameter_semanticIndex_set" "', argument " "2"" of type '" "uint16_t""'");
  } 
  arg2 = static_cast< uint16_t >(val2);
  if (arg1) (arg1)->semanticIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_semanticIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint16_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SigParameter_semanticIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_semanticIndex_get" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result = (uint16_t) ((arg1)->semanticIndex);
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_perPrimitiveRate_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_perPrimitiveRate_set" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigParameter_perPrimitiveRate_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->perPrimitiveRate = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_perPrimitiveRate_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"SigParameter_perPrimitiveRate_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_perPrimitiveRate_get" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result = (bool) ((arg1)->perPrimitiveRate);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_regIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_regIndex_set" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigParameter_regIndex_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->regIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_regIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SigParameter_regIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_regIndex_get" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result = (uint32_t) ((arg1)->regIndex);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_systemValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  ShaderBuiltin arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_systemValue_set" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigParameter_systemValue_set" "', argument " "2"" of type '" "ShaderBuiltin""'");
  } 
  arg2 = static_cast< ShaderBuiltin >(val2);
  if (arg1) (arg1)->systemValue = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_systemValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderBuiltin result;
  
  if (!SWIG_Python_UnpackTuple(args,"SigParameter_systemValue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_systemValue_get" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result = (ShaderBuiltin) ((arg1)->systemValue);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderBuiltin->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_varType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  VarType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_varType_set" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigParameter_varType_set" "', argument " "2"" of type '" "VarType""'");
  } 
  arg2 = static_cast< VarType >(val2);
  if (arg1) (arg1)->varType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_varType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VarType result;
  
  if (!SWIG_Python_UnpackTuple(args,"SigParameter_varType_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_varType_get" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result = (VarType) ((arg1)->varType);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_VarType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_regChannelMask_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_regChannelMask_set" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigParameter_regChannelMask_set" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  if (arg1) (arg1)->regChannelMask = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_regChannelMask_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SigParameter_regChannelMask_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_regChannelMask_get" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result = (uint8_t) ((arg1)->regChannelMask);
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_channelUsedMask_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_channelUsedMask_set" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigParameter_channelUsedMask_set" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  if (arg1) (arg1)->channelUsedMask = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_channelUsedMask_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SigParameter_channelUsedMask_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_channelUsedMask_get" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result = (uint8_t) ((arg1)->channelUsedMask);
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_needSemanticIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_needSemanticIndex_set" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigParameter_needSemanticIndex_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->needSemanticIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_needSemanticIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"SigParameter_needSemanticIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_needSemanticIndex_get" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result = (bool) ((arg1)->needSemanticIndex);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_compCount_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_compCount_set" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigParameter_compCount_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->compCount = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_compCount_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SigParameter_compCount_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_compCount_get" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result = (uint32_t) ((arg1)->compCount);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_stream_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_stream_set" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigParameter_stream_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->stream = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter_stream_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"SigParameter_stream_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter_stream_get" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  result = (uint32_t) ((arg1)->stream);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter___eq__" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)SigParameter___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigParameter___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigParameter___ne__" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)SigParameter___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SigParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SigParameter *arg1 = (SigParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_SigParameter",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SigParameter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SigParameter" "', argument " "1"" of type '" "SigParameter *""'"); 
  }
  arg1 = reinterpret_cast< SigParameter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_SigParameter) /* defines _wrap_delete_SigParameter_destructor_closure */

SWIGINTERN int _wrap_new_ShaderConstantType__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderConstantType *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderConstantType *)new ShaderConstantType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderConstantType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderConstantType__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderConstantType *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderConstantType,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderConstantType" "', argument " "1"" of type '" "ShaderConstantType const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderConstantType" "', argument " "1"" of type '" "ShaderConstantType const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  result = (ShaderConstantType *)new ShaderConstantType((ShaderConstantType const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderConstantType, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderConstantType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderConstantType",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderConstantType__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderConstantType__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderConstantType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderConstantType::ShaderConstantType()\n"
    "    ShaderConstantType::ShaderConstantType(ShaderConstantType const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  ShaderConstantType *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType___eq__" "', argument " "1"" of type '" "ShaderConstantType const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderConstantType,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderConstantType___eq__" "', argument " "2"" of type '" "ShaderConstantType const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderConstantType___eq__" "', argument " "2"" of type '" "ShaderConstantType const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderConstantType * >(argp2);
  result = (bool)((ShaderConstantType const *)arg1)->operator ==((ShaderConstantType const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  ShaderConstantType *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType___lt__" "', argument " "1"" of type '" "ShaderConstantType const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderConstantType,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderConstantType___lt__" "', argument " "2"" of type '" "ShaderConstantType const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderConstantType___lt__" "', argument " "2"" of type '" "ShaderConstantType const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderConstantType * >(argp2);
  result = (bool)((ShaderConstantType const *)arg1)->operator <((ShaderConstantType const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_name_set" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderConstantType_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstantType_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_name_get" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_members_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  rdcarray< ShaderConstant > *arg2 = (rdcarray< ShaderConstant > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_members_set" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderConstantType_members_set' argument 2 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderConstantType_members_set' argument 2 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->members = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_members_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderConstant > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstantType_members_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_members_get" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  result = (rdcarray< ShaderConstant > *)& ((arg1)->members);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderConstant_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  ShaderVariableFlags arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_flags_set" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderConstantType_flags_set" "', argument " "2"" of type '" "ShaderVariableFlags""'");
  } 
  arg2 = static_cast< ShaderVariableFlags >(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderVariableFlags result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstantType_flags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_flags_get" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  result = (ShaderVariableFlags) ((arg1)->flags);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderVariableFlags->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_pointerTypeID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_pointerTypeID_set" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderConstantType_pointerTypeID_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->pointerTypeID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_pointerTypeID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstantType_pointerTypeID_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_pointerTypeID_get" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  result = (uint32_t) ((arg1)->pointerTypeID);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_elements_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_elements_set" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderConstantType_elements_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->elements = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_elements_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstantType_elements_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_elements_get" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  result = (uint32_t) ((arg1)->elements);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_arrayByteStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_arrayByteStride_set" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderConstantType_arrayByteStride_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->arrayByteStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_arrayByteStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstantType_arrayByteStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_arrayByteStride_get" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  result = (uint32_t) ((arg1)->arrayByteStride);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_baseType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  VarType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_baseType_set" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderConstantType_baseType_set" "', argument " "2"" of type '" "VarType""'");
  } 
  arg2 = static_cast< VarType >(val2);
  if (arg1) (arg1)->baseType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_baseType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VarType result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstantType_baseType_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_baseType_get" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  result = (VarType) ((arg1)->baseType);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_VarType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_rows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_rows_set" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderConstantType_rows_set" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  if (arg1) (arg1)->rows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_rows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstantType_rows_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_rows_get" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  result = (uint8_t) ((arg1)->rows);
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_columns_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_columns_set" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderConstantType_columns_set" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  if (arg1) (arg1)->columns = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_columns_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstantType_columns_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_columns_get" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  result = (uint8_t) ((arg1)->columns);
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_matrixByteStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_matrixByteStride_set" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderConstantType_matrixByteStride_set" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  if (arg1) (arg1)->matrixByteStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_matrixByteStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstantType_matrixByteStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_matrixByteStride_get" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  result = (uint8_t) ((arg1)->matrixByteStride);
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_RowMajor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstantType_RowMajor",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_RowMajor" "', argument " "1"" of type '" "ShaderConstantType const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  result = (bool)((ShaderConstantType const *)arg1)->RowMajor();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstantType_ColMajor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstantType_ColMajor",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstantType_ColMajor" "', argument " "1"" of type '" "ShaderConstantType const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  result = (bool)((ShaderConstantType const *)arg1)->ColMajor();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderConstantType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstantType *arg1 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderConstantType",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstantType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderConstantType" "', argument " "1"" of type '" "ShaderConstantType *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstantType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderConstantType) /* defines _wrap_delete_ShaderConstantType_destructor_closure */

SWIGINTERN int _wrap_new_ShaderConstant__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderConstant *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderConstant *)new ShaderConstant();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderConstant, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderConstant__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderConstant *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderConstant,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderConstant" "', argument " "1"" of type '" "ShaderConstant const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderConstant" "', argument " "1"" of type '" "ShaderConstant const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  result = (ShaderConstant *)new ShaderConstant((ShaderConstant const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderConstant, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderConstant(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderConstant",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderConstant__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderConstant__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderConstant'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderConstant::ShaderConstant()\n"
    "    ShaderConstant::ShaderConstant(ShaderConstant const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderConstant___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  ShaderConstant *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant___lt__" "', argument " "1"" of type '" "ShaderConstant const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderConstant,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderConstant___lt__" "', argument " "2"" of type '" "ShaderConstant const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderConstant___lt__" "', argument " "2"" of type '" "ShaderConstant const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderConstant * >(argp2);
  result = (bool)((ShaderConstant const *)arg1)->operator <((ShaderConstant const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant_name_set" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderConstant_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstant_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant_name_get" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant_byteOffset_set" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderConstant_byteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstant_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant_byteOffset_get" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  result = (uint32_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant_bitFieldOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  uint16_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant_bitFieldOffset_set" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderConstant_bitFieldOffset_set" "', argument " "2"" of type '" "uint16_t""'");
  } 
  arg2 = static_cast< uint16_t >(val2);
  if (arg1) (arg1)->bitFieldOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant_bitFieldOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint16_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstant_bitFieldOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant_bitFieldOffset_get" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  result = (uint16_t) ((arg1)->bitFieldOffset);
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant_bitFieldSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  uint16_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant_bitFieldSize_set" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderConstant_bitFieldSize_set" "', argument " "2"" of type '" "uint16_t""'");
  } 
  arg2 = static_cast< uint16_t >(val2);
  if (arg1) (arg1)->bitFieldSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant_bitFieldSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint16_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstant_bitFieldSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant_bitFieldSize_get" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  result = (uint16_t) ((arg1)->bitFieldSize);
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant_defaultValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant_defaultValue_set" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderConstant_defaultValue_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->defaultValue = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant_defaultValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstant_defaultValue_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant_defaultValue_get" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  result = (uint64_t) ((arg1)->defaultValue);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  ShaderConstantType *arg2 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant_type_set" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderConstant_type_set" "', argument " "2"" of type '" "ShaderConstantType *""'"); 
  }
  arg2 = reinterpret_cast< ShaderConstantType * >(argp2);
  if (arg1) (arg1)->type = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderConstantType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderConstant_type_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant_type_get" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  result = (ShaderConstantType *)& ((arg1)->type);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant___eq__" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderConstant___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderConstant___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderConstant___ne__" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderConstant___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderConstant(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderConstant *arg1 = (ShaderConstant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderConstant",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderConstant, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderConstant" "', argument " "1"" of type '" "ShaderConstant *""'"); 
  }
  arg1 = reinterpret_cast< ShaderConstant * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderConstant) /* defines _wrap_delete_ShaderConstant_destructor_closure */

SWIGINTERN int _wrap_new_ConstantBlock__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ConstantBlock *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ConstantBlock *)new ConstantBlock();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConstantBlock, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ConstantBlock__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ConstantBlock *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ConstantBlock,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantBlock" "', argument " "1"" of type '" "ConstantBlock const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBlock" "', argument " "1"" of type '" "ConstantBlock const &""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  result = (ConstantBlock *)new ConstantBlock((ConstantBlock const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConstantBlock, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ConstantBlock(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ConstantBlock",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ConstantBlock__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ConstantBlock__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConstantBlock'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConstantBlock::ConstantBlock()\n"
    "    ConstantBlock::ConstantBlock(ConstantBlock const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ConstantBlock___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  ConstantBlock *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock___lt__" "', argument " "1"" of type '" "ConstantBlock const *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ConstantBlock,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantBlock___lt__" "', argument " "2"" of type '" "ConstantBlock const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantBlock___lt__" "', argument " "2"" of type '" "ConstantBlock const &""'"); 
  }
  arg2 = reinterpret_cast< ConstantBlock * >(argp2);
  result = (bool)((ConstantBlock const *)arg1)->operator <((ConstantBlock const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_name_set" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ConstantBlock_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBlock_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_name_get" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_variables_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  rdcarray< ShaderConstant > *arg2 = (rdcarray< ShaderConstant > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_variables_set" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ConstantBlock_variables_set' argument 2 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ConstantBlock_variables_set' argument 2 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->variables = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_variables_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderConstant > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBlock_variables_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_variables_get" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  result = (rdcarray< ShaderConstant > *)& ((arg1)->variables);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderConstant_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_fixedBindNumber_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_fixedBindNumber_set" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstantBlock_fixedBindNumber_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->fixedBindNumber = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_fixedBindNumber_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBlock_fixedBindNumber_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_fixedBindNumber_get" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  result = (uint32_t) ((arg1)->fixedBindNumber);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_fixedBindSetOrSpace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_fixedBindSetOrSpace_set" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstantBlock_fixedBindSetOrSpace_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->fixedBindSetOrSpace = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_fixedBindSetOrSpace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBlock_fixedBindSetOrSpace_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_fixedBindSetOrSpace_get" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  result = (uint32_t) ((arg1)->fixedBindSetOrSpace);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_bindArraySize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_bindArraySize_set" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstantBlock_bindArraySize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->bindArraySize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_bindArraySize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBlock_bindArraySize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_bindArraySize_get" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  result = (uint32_t) ((arg1)->bindArraySize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_byteSize_set" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstantBlock_byteSize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBlock_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_byteSize_get" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  result = (uint32_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_bufferBacked_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_bufferBacked_set" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstantBlock_bufferBacked_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->bufferBacked = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_bufferBacked_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBlock_bufferBacked_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_bufferBacked_get" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  result = (bool) ((arg1)->bufferBacked);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_inlineDataBytes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_inlineDataBytes_set" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstantBlock_inlineDataBytes_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->inlineDataBytes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_inlineDataBytes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBlock_inlineDataBytes_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_inlineDataBytes_get" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  result = (bool) ((arg1)->inlineDataBytes);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_compileConstants_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_compileConstants_set" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstantBlock_compileConstants_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->compileConstants = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock_compileConstants_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ConstantBlock_compileConstants_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock_compileConstants_get" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  result = (bool) ((arg1)->compileConstants);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock___eq__" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ConstantBlock___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantBlock___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBlock___ne__" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ConstantBlock___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ConstantBlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantBlock *arg1 = (ConstantBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ConstantBlock",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ConstantBlock, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstantBlock" "', argument " "1"" of type '" "ConstantBlock *""'"); 
  }
  arg1 = reinterpret_cast< ConstantBlock * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ConstantBlock) /* defines _wrap_delete_ConstantBlock_destructor_closure */

SWIGINTERN int _wrap_new_ShaderSampler__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderSampler *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderSampler *)new ShaderSampler();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderSampler, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderSampler__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderSampler *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderSampler *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderSampler,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderSampler" "', argument " "1"" of type '" "ShaderSampler const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderSampler" "', argument " "1"" of type '" "ShaderSampler const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderSampler * >(argp1);
  result = (ShaderSampler *)new ShaderSampler((ShaderSampler const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderSampler, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderSampler(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderSampler",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderSampler__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderSampler__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderSampler'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderSampler::ShaderSampler()\n"
    "    ShaderSampler::ShaderSampler(ShaderSampler const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderSampler___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSampler *arg1 = (ShaderSampler *) 0 ;
  ShaderSampler *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSampler___lt__" "', argument " "1"" of type '" "ShaderSampler const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSampler * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderSampler,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderSampler___lt__" "', argument " "2"" of type '" "ShaderSampler const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderSampler___lt__" "', argument " "2"" of type '" "ShaderSampler const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderSampler * >(argp2);
  result = (bool)((ShaderSampler const *)arg1)->operator <((ShaderSampler const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSampler_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSampler *arg1 = (ShaderSampler *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSampler_name_set" "', argument " "1"" of type '" "ShaderSampler *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSampler * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderSampler_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSampler_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSampler *arg1 = (ShaderSampler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderSampler_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSampler_name_get" "', argument " "1"" of type '" "ShaderSampler *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSampler * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSampler_fixedBindNumber_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSampler *arg1 = (ShaderSampler *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSampler_fixedBindNumber_set" "', argument " "1"" of type '" "ShaderSampler *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSampler * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderSampler_fixedBindNumber_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->fixedBindNumber = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSampler_fixedBindNumber_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSampler *arg1 = (ShaderSampler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderSampler_fixedBindNumber_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSampler_fixedBindNumber_get" "', argument " "1"" of type '" "ShaderSampler *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSampler * >(argp1);
  result = (uint32_t) ((arg1)->fixedBindNumber);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSampler_fixedBindSetOrSpace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSampler *arg1 = (ShaderSampler *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSampler_fixedBindSetOrSpace_set" "', argument " "1"" of type '" "ShaderSampler *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSampler * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderSampler_fixedBindSetOrSpace_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->fixedBindSetOrSpace = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSampler_fixedBindSetOrSpace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSampler *arg1 = (ShaderSampler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderSampler_fixedBindSetOrSpace_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSampler_fixedBindSetOrSpace_get" "', argument " "1"" of type '" "ShaderSampler *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSampler * >(argp1);
  result = (uint32_t) ((arg1)->fixedBindSetOrSpace);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSampler_bindArraySize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSampler *arg1 = (ShaderSampler *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSampler_bindArraySize_set" "', argument " "1"" of type '" "ShaderSampler *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSampler * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderSampler_bindArraySize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->bindArraySize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSampler_bindArraySize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSampler *arg1 = (ShaderSampler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderSampler_bindArraySize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSampler_bindArraySize_get" "', argument " "1"" of type '" "ShaderSampler *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSampler * >(argp1);
  result = (uint32_t) ((arg1)->bindArraySize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSampler___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSampler *arg1 = (ShaderSampler *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSampler___eq__" "', argument " "1"" of type '" "ShaderSampler *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSampler * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderSampler___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSampler___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSampler *arg1 = (ShaderSampler *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSampler___ne__" "', argument " "1"" of type '" "ShaderSampler *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSampler * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderSampler___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderSampler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSampler *arg1 = (ShaderSampler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderSampler",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSampler, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderSampler" "', argument " "1"" of type '" "ShaderSampler *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSampler * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderSampler) /* defines _wrap_delete_ShaderSampler_destructor_closure */

SWIGINTERN int _wrap_new_ShaderResource__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderResource *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderResource *)new ShaderResource();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderResource, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderResource__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderResource *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderResource,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderResource" "', argument " "1"" of type '" "ShaderResource const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderResource" "', argument " "1"" of type '" "ShaderResource const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  result = (ShaderResource *)new ShaderResource((ShaderResource const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderResource, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderResource(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderResource",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderResource__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderResource__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderResource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderResource::ShaderResource()\n"
    "    ShaderResource::ShaderResource(ShaderResource const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderResource___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  ShaderResource *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource___lt__" "', argument " "1"" of type '" "ShaderResource const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderResource,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderResource___lt__" "', argument " "2"" of type '" "ShaderResource const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderResource___lt__" "', argument " "2"" of type '" "ShaderResource const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderResource * >(argp2);
  result = (bool)((ShaderResource const *)arg1)->operator <((ShaderResource const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_textureType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  TextureType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_textureType_set" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderResource_textureType_set" "', argument " "2"" of type '" "TextureType""'");
  } 
  arg2 = static_cast< TextureType >(val2);
  if (arg1) (arg1)->textureType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_textureType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TextureType result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderResource_textureType_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_textureType_get" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  result = (TextureType) ((arg1)->textureType);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_TextureType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_descriptorType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  DescriptorType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_descriptorType_set" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderResource_descriptorType_set" "', argument " "2"" of type '" "DescriptorType""'");
  } 
  arg2 = static_cast< DescriptorType >(val2);
  if (arg1) (arg1)->descriptorType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_descriptorType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DescriptorType result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderResource_descriptorType_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_descriptorType_get" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  result = (DescriptorType) ((arg1)->descriptorType);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_DescriptorType->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_name_set" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderResource_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderResource_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_name_get" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_variableType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  ShaderConstantType *arg2 = (ShaderConstantType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_variableType_set" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderResource_variableType_set" "', argument " "2"" of type '" "ShaderConstantType *""'"); 
  }
  arg2 = reinterpret_cast< ShaderConstantType * >(argp2);
  if (arg1) (arg1)->variableType = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_variableType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderConstantType *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderResource_variableType_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_variableType_get" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  result = (ShaderConstantType *)& ((arg1)->variableType);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderConstantType, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_fixedBindNumber_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_fixedBindNumber_set" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderResource_fixedBindNumber_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->fixedBindNumber = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_fixedBindNumber_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderResource_fixedBindNumber_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_fixedBindNumber_get" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  result = (uint32_t) ((arg1)->fixedBindNumber);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_fixedBindSetOrSpace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_fixedBindSetOrSpace_set" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderResource_fixedBindSetOrSpace_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->fixedBindSetOrSpace = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_fixedBindSetOrSpace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderResource_fixedBindSetOrSpace_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_fixedBindSetOrSpace_get" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  result = (uint32_t) ((arg1)->fixedBindSetOrSpace);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_bindArraySize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_bindArraySize_set" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderResource_bindArraySize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->bindArraySize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_bindArraySize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderResource_bindArraySize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_bindArraySize_get" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  result = (uint32_t) ((arg1)->bindArraySize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_isTexture_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_isTexture_set" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderResource_isTexture_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isTexture = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_isTexture_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderResource_isTexture_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_isTexture_get" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  result = (bool) ((arg1)->isTexture);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_hasSampler_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_hasSampler_set" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderResource_hasSampler_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->hasSampler = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_hasSampler_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderResource_hasSampler_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_hasSampler_get" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  result = (bool) ((arg1)->hasSampler);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_isInputAttachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_isInputAttachment_set" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderResource_isInputAttachment_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isInputAttachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_isInputAttachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderResource_isInputAttachment_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_isInputAttachment_get" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  result = (bool) ((arg1)->isInputAttachment);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_isReadOnly_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_isReadOnly_set" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderResource_isReadOnly_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isReadOnly = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource_isReadOnly_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderResource_isReadOnly_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource_isReadOnly_get" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  result = (bool) ((arg1)->isReadOnly);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource___eq__" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderResource___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderResource___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderResource___ne__" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderResource___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderResource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderResource *arg1 = (ShaderResource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderResource",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderResource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderResource" "', argument " "1"" of type '" "ShaderResource *""'"); 
  }
  arg1 = reinterpret_cast< ShaderResource * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderResource) /* defines _wrap_delete_ShaderResource_destructor_closure */

SWIGINTERN int _wrap_new_ShaderEntryPoint__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderEntryPoint *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderEntryPoint *)new ShaderEntryPoint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderEntryPoint, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderEntryPoint__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderEntryPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderEntryPoint *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderEntryPoint,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderEntryPoint" "', argument " "1"" of type '" "ShaderEntryPoint const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderEntryPoint" "', argument " "1"" of type '" "ShaderEntryPoint const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderEntryPoint * >(argp1);
  result = (ShaderEntryPoint *)new ShaderEntryPoint((ShaderEntryPoint const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderEntryPoint, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderEntryPoint__SWIG_2(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  rdcstr *arg1 = 0 ;
  ShaderStage arg2 ;
  rdcstr temp1 ;
  int val2 ;
  int ecode2 = 0 ;
  ShaderEntryPoint *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    tempset(arg1, &temp1);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg1));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_ShaderEntryPoint' argument 1 of type 'rdcstr'"); 
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShaderEntryPoint" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  result = (ShaderEntryPoint *)new ShaderEntryPoint((rdcstr const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderEntryPoint, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderEntryPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderEntryPoint",0,2,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderEntryPoint__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderEntryPoint__SWIG_1(self, argc, argv);
  }
  if (argc == 2) {
    return _wrap_new_ShaderEntryPoint__SWIG_2(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderEntryPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderEntryPoint::ShaderEntryPoint()\n"
    "    ShaderEntryPoint::ShaderEntryPoint(ShaderEntryPoint const &)\n"
    "    ShaderEntryPoint::ShaderEntryPoint(rdcstr const &,ShaderStage)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderEntryPoint___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderEntryPoint *arg1 = (ShaderEntryPoint *) 0 ;
  ShaderEntryPoint *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderEntryPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderEntryPoint___lt__" "', argument " "1"" of type '" "ShaderEntryPoint const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderEntryPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderEntryPoint,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderEntryPoint___lt__" "', argument " "2"" of type '" "ShaderEntryPoint const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderEntryPoint___lt__" "', argument " "2"" of type '" "ShaderEntryPoint const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderEntryPoint * >(argp2);
  result = (bool)((ShaderEntryPoint const *)arg1)->operator <((ShaderEntryPoint const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderEntryPoint_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderEntryPoint *arg1 = (ShaderEntryPoint *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderEntryPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderEntryPoint_name_set" "', argument " "1"" of type '" "ShaderEntryPoint *""'"); 
  }
  arg1 = reinterpret_cast< ShaderEntryPoint * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderEntryPoint_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderEntryPoint_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderEntryPoint *arg1 = (ShaderEntryPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderEntryPoint_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderEntryPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderEntryPoint_name_get" "', argument " "1"" of type '" "ShaderEntryPoint *""'"); 
  }
  arg1 = reinterpret_cast< ShaderEntryPoint * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderEntryPoint_stage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderEntryPoint *arg1 = (ShaderEntryPoint *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderEntryPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderEntryPoint_stage_set" "', argument " "1"" of type '" "ShaderEntryPoint *""'"); 
  }
  arg1 = reinterpret_cast< ShaderEntryPoint * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderEntryPoint_stage_set" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  if (arg1) (arg1)->stage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderEntryPoint_stage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderEntryPoint *arg1 = (ShaderEntryPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStage result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderEntryPoint_stage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderEntryPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderEntryPoint_stage_get" "', argument " "1"" of type '" "ShaderEntryPoint *""'"); 
  }
  arg1 = reinterpret_cast< ShaderEntryPoint * >(argp1);
  result = (ShaderStage) ((arg1)->stage);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderEntryPoint___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderEntryPoint *arg1 = (ShaderEntryPoint *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderEntryPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderEntryPoint___eq__" "', argument " "1"" of type '" "ShaderEntryPoint *""'"); 
  }
  arg1 = reinterpret_cast< ShaderEntryPoint * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderEntryPoint___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderEntryPoint___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderEntryPoint *arg1 = (ShaderEntryPoint *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderEntryPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderEntryPoint___ne__" "', argument " "1"" of type '" "ShaderEntryPoint *""'"); 
  }
  arg1 = reinterpret_cast< ShaderEntryPoint * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderEntryPoint___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderEntryPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderEntryPoint *arg1 = (ShaderEntryPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderEntryPoint",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderEntryPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderEntryPoint" "', argument " "1"" of type '" "ShaderEntryPoint *""'"); 
  }
  arg1 = reinterpret_cast< ShaderEntryPoint * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderEntryPoint) /* defines _wrap_delete_ShaderEntryPoint_destructor_closure */

SWIGINTERN int _wrap_new_ShaderCompileFlag__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderCompileFlag *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderCompileFlag *)new ShaderCompileFlag();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderCompileFlag, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderCompileFlag__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderCompileFlag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderCompileFlag *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderCompileFlag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderCompileFlag" "', argument " "1"" of type '" "ShaderCompileFlag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderCompileFlag" "', argument " "1"" of type '" "ShaderCompileFlag const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderCompileFlag * >(argp1);
  result = (ShaderCompileFlag *)new ShaderCompileFlag((ShaderCompileFlag const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderCompileFlag, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderCompileFlag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderCompileFlag",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderCompileFlag__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderCompileFlag__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderCompileFlag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderCompileFlag::ShaderCompileFlag()\n"
    "    ShaderCompileFlag::ShaderCompileFlag(ShaderCompileFlag const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderCompileFlag___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderCompileFlag *arg1 = (ShaderCompileFlag *) 0 ;
  ShaderCompileFlag *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderCompileFlag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderCompileFlag___lt__" "', argument " "1"" of type '" "ShaderCompileFlag const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderCompileFlag * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderCompileFlag,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderCompileFlag___lt__" "', argument " "2"" of type '" "ShaderCompileFlag const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderCompileFlag___lt__" "', argument " "2"" of type '" "ShaderCompileFlag const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderCompileFlag * >(argp2);
  result = (bool)((ShaderCompileFlag const *)arg1)->operator <((ShaderCompileFlag const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderCompileFlag_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderCompileFlag *arg1 = (ShaderCompileFlag *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderCompileFlag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderCompileFlag_name_set" "', argument " "1"" of type '" "ShaderCompileFlag *""'"); 
  }
  arg1 = reinterpret_cast< ShaderCompileFlag * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderCompileFlag_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderCompileFlag_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderCompileFlag *arg1 = (ShaderCompileFlag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderCompileFlag_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderCompileFlag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderCompileFlag_name_get" "', argument " "1"" of type '" "ShaderCompileFlag *""'"); 
  }
  arg1 = reinterpret_cast< ShaderCompileFlag * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderCompileFlag_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderCompileFlag *arg1 = (ShaderCompileFlag *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderCompileFlag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderCompileFlag_value_set" "', argument " "1"" of type '" "ShaderCompileFlag *""'"); 
  }
  arg1 = reinterpret_cast< ShaderCompileFlag * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderCompileFlag_value_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderCompileFlag_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderCompileFlag *arg1 = (ShaderCompileFlag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderCompileFlag_value_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderCompileFlag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderCompileFlag_value_get" "', argument " "1"" of type '" "ShaderCompileFlag *""'"); 
  }
  arg1 = reinterpret_cast< ShaderCompileFlag * >(argp1);
  result =  ((arg1)->value);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderCompileFlag___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderCompileFlag *arg1 = (ShaderCompileFlag *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderCompileFlag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderCompileFlag___eq__" "', argument " "1"" of type '" "ShaderCompileFlag *""'"); 
  }
  arg1 = reinterpret_cast< ShaderCompileFlag * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderCompileFlag___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderCompileFlag___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderCompileFlag *arg1 = (ShaderCompileFlag *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderCompileFlag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderCompileFlag___ne__" "', argument " "1"" of type '" "ShaderCompileFlag *""'"); 
  }
  arg1 = reinterpret_cast< ShaderCompileFlag * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderCompileFlag___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderCompileFlag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderCompileFlag *arg1 = (ShaderCompileFlag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderCompileFlag",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderCompileFlag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderCompileFlag" "', argument " "1"" of type '" "ShaderCompileFlag *""'"); 
  }
  arg1 = reinterpret_cast< ShaderCompileFlag * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderCompileFlag) /* defines _wrap_delete_ShaderCompileFlag_destructor_closure */

SWIGINTERN int _wrap_new_ShaderCompileFlags__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderCompileFlags *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderCompileFlags *)new ShaderCompileFlags();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderCompileFlags, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderCompileFlags__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderCompileFlags *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderCompileFlags *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderCompileFlags,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderCompileFlags" "', argument " "1"" of type '" "ShaderCompileFlags const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderCompileFlags" "', argument " "1"" of type '" "ShaderCompileFlags const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderCompileFlags * >(argp1);
  result = (ShaderCompileFlags *)new ShaderCompileFlags((ShaderCompileFlags const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderCompileFlags, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderCompileFlags(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderCompileFlags",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderCompileFlags__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderCompileFlags__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderCompileFlags'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderCompileFlags::ShaderCompileFlags()\n"
    "    ShaderCompileFlags::ShaderCompileFlags(ShaderCompileFlags const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderCompileFlags_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderCompileFlags *arg1 = (ShaderCompileFlags *) 0 ;
  rdcarray< ShaderCompileFlag > *arg2 = (rdcarray< ShaderCompileFlag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderCompileFlags, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderCompileFlags_flags_set" "', argument " "1"" of type '" "ShaderCompileFlags *""'"); 
  }
  arg1 = reinterpret_cast< ShaderCompileFlags * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderCompileFlags_flags_set' argument 2 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderCompileFlags_flags_set' argument 2 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->flags = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderCompileFlags_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderCompileFlags *arg1 = (ShaderCompileFlags *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderCompileFlag > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderCompileFlags_flags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderCompileFlags, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderCompileFlags_flags_get" "', argument " "1"" of type '" "ShaderCompileFlags *""'"); 
  }
  arg1 = reinterpret_cast< ShaderCompileFlags * >(argp1);
  result = (rdcarray< ShaderCompileFlag > *)& ((arg1)->flags);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderCompileFlag_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderCompileFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderCompileFlags *arg1 = (ShaderCompileFlags *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderCompileFlags",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderCompileFlags, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderCompileFlags" "', argument " "1"" of type '" "ShaderCompileFlags *""'"); 
  }
  arg1 = reinterpret_cast< ShaderCompileFlags * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderCompileFlags) /* defines _wrap_delete_ShaderCompileFlags_destructor_closure */

SWIGINTERN int _wrap_new_ShaderSourcePrefix__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderSourcePrefix *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderSourcePrefix *)new ShaderSourcePrefix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderSourcePrefix, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderSourcePrefix__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderSourcePrefix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderSourcePrefix *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderSourcePrefix,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderSourcePrefix" "', argument " "1"" of type '" "ShaderSourcePrefix const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderSourcePrefix" "', argument " "1"" of type '" "ShaderSourcePrefix const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourcePrefix * >(argp1);
  result = (ShaderSourcePrefix *)new ShaderSourcePrefix((ShaderSourcePrefix const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderSourcePrefix, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderSourcePrefix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderSourcePrefix",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderSourcePrefix__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderSourcePrefix__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderSourcePrefix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderSourcePrefix::ShaderSourcePrefix()\n"
    "    ShaderSourcePrefix::ShaderSourcePrefix(ShaderSourcePrefix const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderSourcePrefix___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourcePrefix *arg1 = (ShaderSourcePrefix *) 0 ;
  ShaderSourcePrefix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourcePrefix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSourcePrefix___eq__" "', argument " "1"" of type '" "ShaderSourcePrefix const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourcePrefix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderSourcePrefix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderSourcePrefix___eq__" "', argument " "2"" of type '" "ShaderSourcePrefix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderSourcePrefix___eq__" "', argument " "2"" of type '" "ShaderSourcePrefix const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderSourcePrefix * >(argp2);
  result = (bool)((ShaderSourcePrefix const *)arg1)->operator ==((ShaderSourcePrefix const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSourcePrefix___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourcePrefix *arg1 = (ShaderSourcePrefix *) 0 ;
  ShaderSourcePrefix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourcePrefix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSourcePrefix___lt__" "', argument " "1"" of type '" "ShaderSourcePrefix const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourcePrefix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderSourcePrefix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderSourcePrefix___lt__" "', argument " "2"" of type '" "ShaderSourcePrefix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderSourcePrefix___lt__" "', argument " "2"" of type '" "ShaderSourcePrefix const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderSourcePrefix * >(argp2);
  result = (bool)((ShaderSourcePrefix const *)arg1)->operator <((ShaderSourcePrefix const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSourcePrefix_encoding_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourcePrefix *arg1 = (ShaderSourcePrefix *) 0 ;
  ShaderEncoding arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourcePrefix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSourcePrefix_encoding_set" "', argument " "1"" of type '" "ShaderSourcePrefix *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourcePrefix * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderSourcePrefix_encoding_set" "', argument " "2"" of type '" "ShaderEncoding""'");
  } 
  arg2 = static_cast< ShaderEncoding >(val2);
  if (arg1) (arg1)->encoding = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSourcePrefix_encoding_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourcePrefix *arg1 = (ShaderSourcePrefix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderEncoding result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderSourcePrefix_encoding_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourcePrefix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSourcePrefix_encoding_get" "', argument " "1"" of type '" "ShaderSourcePrefix *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourcePrefix * >(argp1);
  result = (ShaderEncoding) ((arg1)->encoding);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderEncoding->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSourcePrefix_prefix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourcePrefix *arg1 = (ShaderSourcePrefix *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourcePrefix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSourcePrefix_prefix_set" "', argument " "1"" of type '" "ShaderSourcePrefix *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourcePrefix * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderSourcePrefix_prefix_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->prefix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSourcePrefix_prefix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourcePrefix *arg1 = (ShaderSourcePrefix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderSourcePrefix_prefix_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourcePrefix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSourcePrefix_prefix_get" "', argument " "1"" of type '" "ShaderSourcePrefix *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourcePrefix * >(argp1);
  result =  ((arg1)->prefix);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderSourcePrefix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourcePrefix *arg1 = (ShaderSourcePrefix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderSourcePrefix",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourcePrefix, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderSourcePrefix" "', argument " "1"" of type '" "ShaderSourcePrefix *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourcePrefix * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderSourcePrefix) /* defines _wrap_delete_ShaderSourcePrefix_destructor_closure */

SWIGINTERN int _wrap_new_ShaderSourceFile__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderSourceFile *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderSourceFile *)new ShaderSourceFile();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderSourceFile, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderSourceFile__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderSourceFile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderSourceFile *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderSourceFile,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderSourceFile" "', argument " "1"" of type '" "ShaderSourceFile const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderSourceFile" "', argument " "1"" of type '" "ShaderSourceFile const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourceFile * >(argp1);
  result = (ShaderSourceFile *)new ShaderSourceFile((ShaderSourceFile const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderSourceFile, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderSourceFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderSourceFile",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderSourceFile__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderSourceFile__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderSourceFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderSourceFile::ShaderSourceFile()\n"
    "    ShaderSourceFile::ShaderSourceFile(ShaderSourceFile const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderSourceFile___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourceFile *arg1 = (ShaderSourceFile *) 0 ;
  ShaderSourceFile *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourceFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSourceFile___lt__" "', argument " "1"" of type '" "ShaderSourceFile const *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourceFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ShaderSourceFile,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderSourceFile___lt__" "', argument " "2"" of type '" "ShaderSourceFile const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShaderSourceFile___lt__" "', argument " "2"" of type '" "ShaderSourceFile const &""'"); 
  }
  arg2 = reinterpret_cast< ShaderSourceFile * >(argp2);
  result = (bool)((ShaderSourceFile const *)arg1)->operator <((ShaderSourceFile const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSourceFile_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourceFile *arg1 = (ShaderSourceFile *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourceFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSourceFile_filename_set" "', argument " "1"" of type '" "ShaderSourceFile *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourceFile * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderSourceFile_filename_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->filename = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSourceFile_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourceFile *arg1 = (ShaderSourceFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderSourceFile_filename_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourceFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSourceFile_filename_get" "', argument " "1"" of type '" "ShaderSourceFile *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourceFile * >(argp1);
  result =  ((arg1)->filename);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSourceFile_contents_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourceFile *arg1 = (ShaderSourceFile *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourceFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSourceFile_contents_set" "', argument " "1"" of type '" "ShaderSourceFile *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourceFile * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderSourceFile_contents_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->contents = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSourceFile_contents_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourceFile *arg1 = (ShaderSourceFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderSourceFile_contents_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourceFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSourceFile_contents_get" "', argument " "1"" of type '" "ShaderSourceFile *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourceFile * >(argp1);
  result =  ((arg1)->contents);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSourceFile___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourceFile *arg1 = (ShaderSourceFile *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourceFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSourceFile___eq__" "', argument " "1"" of type '" "ShaderSourceFile *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourceFile * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderSourceFile___eq__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderSourceFile___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourceFile *arg1 = (ShaderSourceFile *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourceFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderSourceFile___ne__" "', argument " "1"" of type '" "ShaderSourceFile *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourceFile * >(argp1);
  arg2 = swig_obj[0];
  result = (PyObject *)ShaderSourceFile___ne__(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderSourceFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderSourceFile *arg1 = (ShaderSourceFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderSourceFile",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderSourceFile, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderSourceFile" "', argument " "1"" of type '" "ShaderSourceFile *""'"); 
  }
  arg1 = reinterpret_cast< ShaderSourceFile * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderSourceFile) /* defines _wrap_delete_ShaderSourceFile_destructor_closure */

SWIGINTERN int _wrap_new_ShaderDebugInfo__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderDebugInfo *)new ShaderDebugInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDebugInfo, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderDebugInfo__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderDebugInfo *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderDebugInfo,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderDebugInfo" "', argument " "1"" of type '" "ShaderDebugInfo const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderDebugInfo" "', argument " "1"" of type '" "ShaderDebugInfo const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  result = (ShaderDebugInfo *)new ShaderDebugInfo((ShaderDebugInfo const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDebugInfo, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderDebugInfo(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderDebugInfo",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderDebugInfo__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderDebugInfo__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderDebugInfo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderDebugInfo::ShaderDebugInfo()\n"
    "    ShaderDebugInfo::ShaderDebugInfo(ShaderDebugInfo const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_compileFlags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  ShaderCompileFlags *arg2 = (ShaderCompileFlags *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_compileFlags_set" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderCompileFlags, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderDebugInfo_compileFlags_set" "', argument " "2"" of type '" "ShaderCompileFlags *""'"); 
  }
  arg2 = reinterpret_cast< ShaderCompileFlags * >(argp2);
  if (arg1) (arg1)->compileFlags = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_compileFlags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderCompileFlags *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugInfo_compileFlags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_compileFlags_get" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  result = (ShaderCompileFlags *)& ((arg1)->compileFlags);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderCompileFlags, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_files_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  rdcarray< ShaderSourceFile > *arg2 = (rdcarray< ShaderSourceFile > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_files_set" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderDebugInfo_files_set' argument 2 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderDebugInfo_files_set' argument 2 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->files = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_files_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderSourceFile > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugInfo_files_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_files_get" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  result = (rdcarray< ShaderSourceFile > *)& ((arg1)->files);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderSourceFile_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_entrySourceName_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_entrySourceName_set" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderDebugInfo_entrySourceName_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->entrySourceName = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_entrySourceName_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugInfo_entrySourceName_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_entrySourceName_get" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  result =  ((arg1)->entrySourceName);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_entryLocation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  LineColumnInfo *arg2 = (LineColumnInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_entryLocation_set" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderDebugInfo_entryLocation_set" "', argument " "2"" of type '" "LineColumnInfo *""'"); 
  }
  arg2 = reinterpret_cast< LineColumnInfo * >(argp2);
  if (arg1) (arg1)->entryLocation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_entryLocation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  LineColumnInfo *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugInfo_entryLocation_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_entryLocation_get" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  result = (LineColumnInfo *)& ((arg1)->entryLocation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LineColumnInfo, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_editBaseFile_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_editBaseFile_set" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderDebugInfo_editBaseFile_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->editBaseFile = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_editBaseFile_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugInfo_editBaseFile_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_editBaseFile_get" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  result = (int32_t) ((arg1)->editBaseFile);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_encoding_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  ShaderEncoding arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_encoding_set" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderDebugInfo_encoding_set" "', argument " "2"" of type '" "ShaderEncoding""'");
  } 
  arg2 = static_cast< ShaderEncoding >(val2);
  if (arg1) (arg1)->encoding = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_encoding_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderEncoding result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugInfo_encoding_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_encoding_get" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  result = (ShaderEncoding) ((arg1)->encoding);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderEncoding->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_compiler_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  KnownShaderTool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_compiler_set" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderDebugInfo_compiler_set" "', argument " "2"" of type '" "KnownShaderTool""'");
  } 
  arg2 = static_cast< KnownShaderTool >(val2);
  if (arg1) (arg1)->compiler = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_compiler_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  KnownShaderTool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugInfo_compiler_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_compiler_get" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  result = (KnownShaderTool) ((arg1)->compiler);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_KnownShaderTool->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_debuggable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_debuggable_set" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderDebugInfo_debuggable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->debuggable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_debuggable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugInfo_debuggable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_debuggable_get" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  result = (bool) ((arg1)->debuggable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_sourceDebugInformation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_sourceDebugInformation_set" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderDebugInfo_sourceDebugInformation_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->sourceDebugInformation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_sourceDebugInformation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugInfo_sourceDebugInformation_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_sourceDebugInformation_get" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  result = (bool) ((arg1)->sourceDebugInformation);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_debugStatus_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_debugStatus_set" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderDebugInfo_debugStatus_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->debugStatus = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_debugStatus_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugInfo_debugStatus_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_debugStatus_get" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  result =  ((arg1)->debugStatus);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_debugInfoLoadingLog_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_debugInfoLoadingLog_set" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderDebugInfo_debugInfoLoadingLog_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->debugInfoLoadingLog = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderDebugInfo_debugInfoLoadingLog_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderDebugInfo_debugInfoLoadingLog_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderDebugInfo_debugInfoLoadingLog_get" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  result =  ((arg1)->debugInfoLoadingLog);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderDebugInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderDebugInfo *arg1 = (ShaderDebugInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderDebugInfo",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderDebugInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderDebugInfo" "', argument " "1"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg1 = reinterpret_cast< ShaderDebugInfo * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderDebugInfo) /* defines _wrap_delete_ShaderDebugInfo_destructor_closure */

SWIGINTERN int _wrap_new_ShaderReflection__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ShaderReflection *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ShaderReflection *)new ShaderReflection();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderReflection, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderReflection__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ShaderReflection *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ShaderReflection,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShaderReflection" "', argument " "1"" of type '" "ShaderReflection const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShaderReflection" "', argument " "1"" of type '" "ShaderReflection const &""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (ShaderReflection *)new ShaderReflection((ShaderReflection const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderReflection, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_ShaderReflection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_ShaderReflection",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShaderReflection__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_ShaderReflection__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShaderReflection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ShaderReflection::ShaderReflection()\n"
    "    ShaderReflection::ShaderReflection(ShaderReflection const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_resourceId_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderReflection_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_resourceId_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_entryPoint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_entryPoint_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderReflection_entryPoint_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->entryPoint = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_entryPoint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_entryPoint_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_entryPoint_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result =  ((arg1)->entryPoint);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_stage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_stage_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderReflection_stage_set" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  if (arg1) (arg1)->stage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_stage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStage result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_stage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_stage_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (ShaderStage) ((arg1)->stage);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_debugInfo_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  ShaderDebugInfo *arg2 = (ShaderDebugInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_debugInfo_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderReflection_debugInfo_set" "', argument " "2"" of type '" "ShaderDebugInfo *""'"); 
  }
  arg2 = reinterpret_cast< ShaderDebugInfo * >(argp2);
  if (arg1) (arg1)->debugInfo = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_debugInfo_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderDebugInfo *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_debugInfo_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_debugInfo_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (ShaderDebugInfo *)& ((arg1)->debugInfo);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderDebugInfo, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_encoding_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  ShaderEncoding arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_encoding_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderReflection_encoding_set" "', argument " "2"" of type '" "ShaderEncoding""'");
  } 
  arg2 = static_cast< ShaderEncoding >(val2);
  if (arg1) (arg1)->encoding = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_encoding_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderEncoding result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_encoding_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_encoding_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (ShaderEncoding) ((arg1)->encoding);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderEncoding->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_rawBytes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  bytebuf *arg2 = (bytebuf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bytebuf temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_rawBytes_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderReflection_rawBytes_set' argument 2 of type 'bytebuf'"); 
    }
  }
  if (arg1) (arg1)->rawBytes = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_rawBytes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bytebuf *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_rawBytes_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_rawBytes_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (bytebuf *)& ((arg1)->rawBytes);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_dispatchThreadsDimension_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  rdcfixedarray< uint32_t,3 > *arg2 = (rdcfixedarray< uint32_t,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_dispatchThreadsDimension_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderReflection_dispatchThreadsDimension_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderReflection_dispatchThreadsDimension_set' argument 2 of type 'rdcfixedarray< uint32_t,3 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->dispatchThreadsDimension = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_dispatchThreadsDimension_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< uint32_t,3 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_dispatchThreadsDimension_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_dispatchThreadsDimension_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (rdcfixedarray< uint32_t,3 > *)& ((arg1)->dispatchThreadsDimension);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_outputTopology_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  Topology arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_outputTopology_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShaderReflection_outputTopology_set" "', argument " "2"" of type '" "Topology""'");
  } 
  arg2 = static_cast< Topology >(val2);
  if (arg1) (arg1)->outputTopology = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_outputTopology_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Topology result;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_outputTopology_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_outputTopology_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (Topology) ((arg1)->outputTopology);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_Topology->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_inputSignature_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  rdcarray< SigParameter > *arg2 = (rdcarray< SigParameter > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_inputSignature_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderReflection_inputSignature_set' argument 2 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderReflection_inputSignature_set' argument 2 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->inputSignature = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_inputSignature_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< SigParameter > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_inputSignature_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_inputSignature_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (rdcarray< SigParameter > *)& ((arg1)->inputSignature);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_SigParameter_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_outputSignature_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  rdcarray< SigParameter > *arg2 = (rdcarray< SigParameter > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_outputSignature_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderReflection_outputSignature_set' argument 2 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderReflection_outputSignature_set' argument 2 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->outputSignature = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_outputSignature_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< SigParameter > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_outputSignature_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_outputSignature_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (rdcarray< SigParameter > *)& ((arg1)->outputSignature);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_SigParameter_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_constantBlocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  rdcarray< ConstantBlock > *arg2 = (rdcarray< ConstantBlock > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_constantBlocks_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderReflection_constantBlocks_set' argument 2 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderReflection_constantBlocks_set' argument 2 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->constantBlocks = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_constantBlocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ConstantBlock > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_constantBlocks_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_constantBlocks_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (rdcarray< ConstantBlock > *)& ((arg1)->constantBlocks);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ConstantBlock_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_samplers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  rdcarray< ShaderSampler > *arg2 = (rdcarray< ShaderSampler > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_samplers_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderReflection_samplers_set' argument 2 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderReflection_samplers_set' argument 2 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->samplers = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_samplers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderSampler > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_samplers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_samplers_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (rdcarray< ShaderSampler > *)& ((arg1)->samplers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderSampler_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_readOnlyResources_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  rdcarray< ShaderResource > *arg2 = (rdcarray< ShaderResource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_readOnlyResources_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderReflection_readOnlyResources_set' argument 2 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderReflection_readOnlyResources_set' argument 2 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->readOnlyResources = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_readOnlyResources_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderResource > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_readOnlyResources_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_readOnlyResources_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (rdcarray< ShaderResource > *)& ((arg1)->readOnlyResources);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderResource_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_readWriteResources_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  rdcarray< ShaderResource > *arg2 = (rdcarray< ShaderResource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_readWriteResources_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderReflection_readWriteResources_set' argument 2 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderReflection_readWriteResources_set' argument 2 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->readWriteResources = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_readWriteResources_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderResource > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_readWriteResources_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_readWriteResources_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (rdcarray< ShaderResource > *)& ((arg1)->readWriteResources);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderResource_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_interfaces_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  rdcarray< rdcstr > *arg2 = (rdcarray< rdcstr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_interfaces_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderReflection_interfaces_set' argument 2 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderReflection_interfaces_set' argument 2 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->interfaces = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_interfaces_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< rdcstr > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_interfaces_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_interfaces_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (rdcarray< rdcstr > *)& ((arg1)->interfaces);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_rdcstr_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_pointerTypes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  rdcarray< ShaderConstantType > *arg2 = (rdcarray< ShaderConstantType > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_pointerTypes_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'ShaderReflection_pointerTypes_set' argument 2 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'ShaderReflection_pointerTypes_set' argument 2 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->pointerTypes = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_pointerTypes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderConstantType > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_pointerTypes_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_pointerTypes_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (rdcarray< ShaderConstantType > *)& ((arg1)->pointerTypes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderConstantType_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_taskPayload_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  ConstantBlock *arg2 = (ConstantBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_taskPayload_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderReflection_taskPayload_set" "', argument " "2"" of type '" "ConstantBlock *""'"); 
  }
  arg2 = reinterpret_cast< ConstantBlock * >(argp2);
  if (arg1) (arg1)->taskPayload = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_taskPayload_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConstantBlock *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_taskPayload_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_taskPayload_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (ConstantBlock *)& ((arg1)->taskPayload);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_rayPayload_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  ConstantBlock *arg2 = (ConstantBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_rayPayload_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderReflection_rayPayload_set" "', argument " "2"" of type '" "ConstantBlock *""'"); 
  }
  arg2 = reinterpret_cast< ConstantBlock * >(argp2);
  if (arg1) (arg1)->rayPayload = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_rayPayload_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConstantBlock *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_rayPayload_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_rayPayload_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (ConstantBlock *)& ((arg1)->rayPayload);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_rayAttributes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  ConstantBlock *arg2 = (ConstantBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_rayAttributes_set" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShaderReflection_rayAttributes_set" "', argument " "2"" of type '" "ConstantBlock *""'"); 
  }
  arg2 = reinterpret_cast< ConstantBlock * >(argp2);
  if (arg1) (arg1)->rayAttributes = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShaderReflection_rayAttributes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConstantBlock *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"ShaderReflection_rayAttributes_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShaderReflection_rayAttributes_get" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  result = (ConstantBlock *)& ((arg1)->rayAttributes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConstantBlock, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShaderReflection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShaderReflection *arg1 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_ShaderReflection",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ShaderReflection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShaderReflection" "', argument " "1"" of type '" "ShaderReflection *""'"); 
  }
  arg1 = reinterpret_cast< ShaderReflection * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_ShaderReflection) /* defines _wrap_delete_ShaderReflection_destructor_closure */

SWIGINTERN int _wrap_new_VKDynamicOffset__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::DynamicOffset *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::DynamicOffset *)new VKPipe::DynamicOffset();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__DynamicOffset, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKDynamicOffset__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::DynamicOffset *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::DynamicOffset *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__DynamicOffset,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKDynamicOffset" "', argument " "1"" of type '" "VKPipe::DynamicOffset const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKDynamicOffset" "', argument " "1"" of type '" "VKPipe::DynamicOffset const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DynamicOffset * >(argp1);
  result = (VKPipe::DynamicOffset *)new VKPipe::DynamicOffset((VKPipe::DynamicOffset const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__DynamicOffset, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKDynamicOffset(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKDynamicOffset",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKDynamicOffset__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKDynamicOffset__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKDynamicOffset'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::DynamicOffset::DynamicOffset()\n"
    "    VKPipe::DynamicOffset::DynamicOffset(VKPipe::DynamicOffset const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKDynamicOffset___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DynamicOffset *arg1 = (VKPipe::DynamicOffset *) 0 ;
  VKPipe::DynamicOffset *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DynamicOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDynamicOffset___eq__" "', argument " "1"" of type '" "VKPipe::DynamicOffset const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DynamicOffset * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__DynamicOffset,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKDynamicOffset___eq__" "', argument " "2"" of type '" "VKPipe::DynamicOffset const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKDynamicOffset___eq__" "', argument " "2"" of type '" "VKPipe::DynamicOffset const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::DynamicOffset * >(argp2);
  result = (bool)((VKPipe::DynamicOffset const *)arg1)->operator ==((VKPipe::DynamicOffset const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDynamicOffset___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DynamicOffset *arg1 = (VKPipe::DynamicOffset *) 0 ;
  VKPipe::DynamicOffset *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DynamicOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDynamicOffset___lt__" "', argument " "1"" of type '" "VKPipe::DynamicOffset const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DynamicOffset * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__DynamicOffset,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKDynamicOffset___lt__" "', argument " "2"" of type '" "VKPipe::DynamicOffset const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKDynamicOffset___lt__" "', argument " "2"" of type '" "VKPipe::DynamicOffset const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::DynamicOffset * >(argp2);
  result = (bool)((VKPipe::DynamicOffset const *)arg1)->operator <((VKPipe::DynamicOffset const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDynamicOffset_descriptorByteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DynamicOffset *arg1 = (VKPipe::DynamicOffset *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DynamicOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDynamicOffset_descriptorByteOffset_set" "', argument " "1"" of type '" "VKPipe::DynamicOffset *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DynamicOffset * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDynamicOffset_descriptorByteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->descriptorByteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDynamicOffset_descriptorByteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DynamicOffset *arg1 = (VKPipe::DynamicOffset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDynamicOffset_descriptorByteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DynamicOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDynamicOffset_descriptorByteOffset_get" "', argument " "1"" of type '" "VKPipe::DynamicOffset *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DynamicOffset * >(argp1);
  result = (uint64_t) ((arg1)->descriptorByteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDynamicOffset_dynamicBufferByteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DynamicOffset *arg1 = (VKPipe::DynamicOffset *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DynamicOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDynamicOffset_dynamicBufferByteOffset_set" "', argument " "1"" of type '" "VKPipe::DynamicOffset *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DynamicOffset * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDynamicOffset_dynamicBufferByteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->dynamicBufferByteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDynamicOffset_dynamicBufferByteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DynamicOffset *arg1 = (VKPipe::DynamicOffset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDynamicOffset_dynamicBufferByteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DynamicOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDynamicOffset_dynamicBufferByteOffset_get" "', argument " "1"" of type '" "VKPipe::DynamicOffset *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DynamicOffset * >(argp1);
  result = (uint64_t) ((arg1)->dynamicBufferByteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKDynamicOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DynamicOffset *arg1 = (VKPipe::DynamicOffset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKDynamicOffset",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DynamicOffset, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKDynamicOffset" "', argument " "1"" of type '" "VKPipe::DynamicOffset *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DynamicOffset * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKDynamicOffset) /* defines _wrap_delete_VKDynamicOffset_destructor_closure */

SWIGINTERN int _wrap_new_VKDescriptorSet__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::DescriptorSet *)new VKPipe::DescriptorSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__DescriptorSet, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKDescriptorSet__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::DescriptorSet *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__DescriptorSet,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKDescriptorSet" "', argument " "1"" of type '" "VKPipe::DescriptorSet const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKDescriptorSet" "', argument " "1"" of type '" "VKPipe::DescriptorSet const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  result = (VKPipe::DescriptorSet *)new VKPipe::DescriptorSet((VKPipe::DescriptorSet const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__DescriptorSet, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKDescriptorSet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKDescriptorSet",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKDescriptorSet__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKDescriptorSet__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKDescriptorSet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::DescriptorSet::DescriptorSet()\n"
    "    VKPipe::DescriptorSet::DescriptorSet(VKPipe::DescriptorSet const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  VKPipe::DescriptorSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet___eq__" "', argument " "1"" of type '" "VKPipe::DescriptorSet const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__DescriptorSet,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKDescriptorSet___eq__" "', argument " "2"" of type '" "VKPipe::DescriptorSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKDescriptorSet___eq__" "', argument " "2"" of type '" "VKPipe::DescriptorSet const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::DescriptorSet * >(argp2);
  result = (bool)((VKPipe::DescriptorSet const *)arg1)->operator ==((VKPipe::DescriptorSet const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  VKPipe::DescriptorSet *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet___lt__" "', argument " "1"" of type '" "VKPipe::DescriptorSet const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__DescriptorSet,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKDescriptorSet___lt__" "', argument " "2"" of type '" "VKPipe::DescriptorSet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKDescriptorSet___lt__" "', argument " "2"" of type '" "VKPipe::DescriptorSet const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::DescriptorSet * >(argp2);
  result = (bool)((VKPipe::DescriptorSet const *)arg1)->operator <((VKPipe::DescriptorSet const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_layoutResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_layoutResourceId_set" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKDescriptorSet_layoutResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->layoutResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_layoutResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDescriptorSet_layoutResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_layoutResourceId_get" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  result = (ResourceId *)& ((arg1)->layoutResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_descriptorSetResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_descriptorSetResourceId_set" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKDescriptorSet_descriptorSetResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->descriptorSetResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_descriptorSetResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDescriptorSet_descriptorSetResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_descriptorSetResourceId_get" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  result = (ResourceId *)& ((arg1)->descriptorSetResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_pushDescriptor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_pushDescriptor_set" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDescriptorSet_pushDescriptor_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->pushDescriptor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_pushDescriptor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDescriptorSet_pushDescriptor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_pushDescriptor_get" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  result = (bool) ((arg1)->pushDescriptor);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_dynamicOffsets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  rdcarray< VKPipe::DynamicOffset > *arg2 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_dynamicOffsets_set" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKDescriptorSet_dynamicOffsets_set' argument 2 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKDescriptorSet_dynamicOffsets_set' argument 2 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->dynamicOffsets = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_dynamicOffsets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< VKPipe::DynamicOffset > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDescriptorSet_dynamicOffsets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_dynamicOffsets_get" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  result = (rdcarray< VKPipe::DynamicOffset > *)& ((arg1)->dynamicOffsets);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_VKPipe__DynamicOffset_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_descriptorBufferIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_descriptorBufferIndex_set" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDescriptorSet_descriptorBufferIndex_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->descriptorBufferIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_descriptorBufferIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDescriptorSet_descriptorBufferIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_descriptorBufferIndex_get" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  result = (int32_t) ((arg1)->descriptorBufferIndex);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_descriptorBufferByteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_descriptorBufferByteOffset_set" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDescriptorSet_descriptorBufferByteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->descriptorBufferByteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_descriptorBufferByteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDescriptorSet_descriptorBufferByteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_descriptorBufferByteOffset_get" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  result = (uint64_t) ((arg1)->descriptorBufferByteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_descriptorBufferEmbeddedSamplers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_descriptorBufferEmbeddedSamplers_set" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDescriptorSet_descriptorBufferEmbeddedSamplers_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->descriptorBufferEmbeddedSamplers = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorSet_descriptorBufferEmbeddedSamplers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDescriptorSet_descriptorBufferEmbeddedSamplers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorSet_descriptorBufferEmbeddedSamplers_get" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  result = (bool) ((arg1)->descriptorBufferEmbeddedSamplers);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKDescriptorSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorSet *arg1 = (VKPipe::DescriptorSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKDescriptorSet",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorSet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKDescriptorSet" "', argument " "1"" of type '" "VKPipe::DescriptorSet *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorSet * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKDescriptorSet) /* defines _wrap_delete_VKDescriptorSet_destructor_closure */

SWIGINTERN int _wrap_new_VKDescriptorBuffer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::DescriptorBuffer *)new VKPipe::DescriptorBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__DescriptorBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKDescriptorBuffer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::DescriptorBuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__DescriptorBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKDescriptorBuffer" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKDescriptorBuffer" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  result = (VKPipe::DescriptorBuffer *)new VKPipe::DescriptorBuffer((VKPipe::DescriptorBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__DescriptorBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKDescriptorBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKDescriptorBuffer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKDescriptorBuffer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKDescriptorBuffer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKDescriptorBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::DescriptorBuffer::DescriptorBuffer()\n"
    "    VKPipe::DescriptorBuffer::DescriptorBuffer(VKPipe::DescriptorBuffer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  VKPipe::DescriptorBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer___eq__" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__DescriptorBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKDescriptorBuffer___eq__" "', argument " "2"" of type '" "VKPipe::DescriptorBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKDescriptorBuffer___eq__" "', argument " "2"" of type '" "VKPipe::DescriptorBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp2);
  result = (bool)((VKPipe::DescriptorBuffer const *)arg1)->operator ==((VKPipe::DescriptorBuffer const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  VKPipe::DescriptorBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer___lt__" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__DescriptorBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKDescriptorBuffer___lt__" "', argument " "2"" of type '" "VKPipe::DescriptorBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKDescriptorBuffer___lt__" "', argument " "2"" of type '" "VKPipe::DescriptorBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp2);
  result = (bool)((VKPipe::DescriptorBuffer const *)arg1)->operator <((VKPipe::DescriptorBuffer const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer_buffer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer_buffer_set" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKDescriptorBuffer_buffer_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->buffer = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer_buffer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDescriptorBuffer_buffer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer_buffer_get" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  result = (ResourceId *)& ((arg1)->buffer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer_offset_set" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDescriptorBuffer_offset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDescriptorBuffer_offset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer_offset_get" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  result = (uint64_t) ((arg1)->offset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer_pushDescriptor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer_pushDescriptor_set" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDescriptorBuffer_pushDescriptor_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->pushDescriptor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer_pushDescriptor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDescriptorBuffer_pushDescriptor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer_pushDescriptor_get" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  result = (bool) ((arg1)->pushDescriptor);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer_pushBuffer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer_pushBuffer_set" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKDescriptorBuffer_pushBuffer_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->pushBuffer = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer_pushBuffer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDescriptorBuffer_pushBuffer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer_pushBuffer_get" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  result = (ResourceId *)& ((arg1)->pushBuffer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer_resourceBuffer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer_resourceBuffer_set" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDescriptorBuffer_resourceBuffer_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->resourceBuffer = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer_resourceBuffer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDescriptorBuffer_resourceBuffer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer_resourceBuffer_get" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  result = (bool) ((arg1)->resourceBuffer);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer_samplerBuffer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer_samplerBuffer_set" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDescriptorBuffer_samplerBuffer_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->samplerBuffer = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDescriptorBuffer_samplerBuffer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDescriptorBuffer_samplerBuffer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDescriptorBuffer_samplerBuffer_get" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  result = (bool) ((arg1)->samplerBuffer);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKDescriptorBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DescriptorBuffer *arg1 = (VKPipe::DescriptorBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKDescriptorBuffer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DescriptorBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKDescriptorBuffer" "', argument " "1"" of type '" "VKPipe::DescriptorBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKDescriptorBuffer) /* defines _wrap_delete_VKDescriptorBuffer_destructor_closure */

SWIGINTERN int _wrap_new_VKPipeline__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::Pipeline *)new VKPipe::Pipeline();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Pipeline, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKPipeline__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::Pipeline *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__Pipeline,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKPipeline" "', argument " "1"" of type '" "VKPipe::Pipeline const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKPipeline" "', argument " "1"" of type '" "VKPipe::Pipeline const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  result = (VKPipe::Pipeline *)new VKPipe::Pipeline((VKPipe::Pipeline const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Pipeline, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKPipeline(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKPipeline",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKPipeline__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKPipeline__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKPipeline'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::Pipeline::Pipeline()\n"
    "    VKPipe::Pipeline::Pipeline(VKPipe::Pipeline const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKPipeline_pipelineResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_pipelineResourceId_set" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKPipeline_pipelineResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->pipelineResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKPipeline_pipelineResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKPipeline_pipelineResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_pipelineResourceId_get" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  result = (ResourceId *)& ((arg1)->pipelineResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKPipeline_pipelineComputeLayoutResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_pipelineComputeLayoutResourceId_set" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKPipeline_pipelineComputeLayoutResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->pipelineComputeLayoutResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKPipeline_pipelineComputeLayoutResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKPipeline_pipelineComputeLayoutResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_pipelineComputeLayoutResourceId_get" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  result = (ResourceId *)& ((arg1)->pipelineComputeLayoutResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKPipeline_pipelinePreRastLayoutResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_pipelinePreRastLayoutResourceId_set" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKPipeline_pipelinePreRastLayoutResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->pipelinePreRastLayoutResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKPipeline_pipelinePreRastLayoutResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKPipeline_pipelinePreRastLayoutResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_pipelinePreRastLayoutResourceId_get" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  result = (ResourceId *)& ((arg1)->pipelinePreRastLayoutResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKPipeline_pipelineFragmentLayoutResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_pipelineFragmentLayoutResourceId_set" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKPipeline_pipelineFragmentLayoutResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->pipelineFragmentLayoutResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKPipeline_pipelineFragmentLayoutResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKPipeline_pipelineFragmentLayoutResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_pipelineFragmentLayoutResourceId_get" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  result = (ResourceId *)& ((arg1)->pipelineFragmentLayoutResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKPipeline_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_flags_set" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKPipeline_flags_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKPipeline_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKPipeline_flags_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_flags_get" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  result = (uint64_t) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKPipeline_descriptorSets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  rdcarray< VKPipe::DescriptorSet > *arg2 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_descriptorSets_set" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKPipeline_descriptorSets_set' argument 2 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKPipeline_descriptorSets_set' argument 2 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->descriptorSets = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKPipeline_descriptorSets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< VKPipe::DescriptorSet > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKPipeline_descriptorSets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_descriptorSets_get" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  result = (rdcarray< VKPipe::DescriptorSet > *)& ((arg1)->descriptorSets);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_VKPipe__DescriptorSet_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKPipeline_descriptorBuffers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  rdcarray< VKPipe::DescriptorBuffer > *arg2 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_descriptorBuffers_set" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKPipeline_descriptorBuffers_set' argument 2 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKPipeline_descriptorBuffers_set' argument 2 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->descriptorBuffers = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKPipeline_descriptorBuffers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< VKPipe::DescriptorBuffer > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKPipeline_descriptorBuffers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKPipeline_descriptorBuffers_get" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  result = (rdcarray< VKPipe::DescriptorBuffer > *)& ((arg1)->descriptorBuffers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_VKPipe__DescriptorBuffer_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKPipeline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Pipeline *arg1 = (VKPipe::Pipeline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKPipeline",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Pipeline, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKPipeline" "', argument " "1"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Pipeline * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKPipeline) /* defines _wrap_delete_VKPipeline_destructor_closure */

SWIGINTERN int _wrap_new_VKIndexBuffer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::IndexBuffer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::IndexBuffer *)new VKPipe::IndexBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__IndexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKIndexBuffer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::IndexBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::IndexBuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__IndexBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKIndexBuffer" "', argument " "1"" of type '" "VKPipe::IndexBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKIndexBuffer" "', argument " "1"" of type '" "VKPipe::IndexBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::IndexBuffer * >(argp1);
  result = (VKPipe::IndexBuffer *)new VKPipe::IndexBuffer((VKPipe::IndexBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__IndexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKIndexBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKIndexBuffer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKIndexBuffer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKIndexBuffer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKIndexBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::IndexBuffer::IndexBuffer()\n"
    "    VKPipe::IndexBuffer::IndexBuffer(VKPipe::IndexBuffer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKIndexBuffer_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::IndexBuffer *arg1 = (VKPipe::IndexBuffer *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKIndexBuffer_resourceId_set" "', argument " "1"" of type '" "VKPipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::IndexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKIndexBuffer_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKIndexBuffer_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::IndexBuffer *arg1 = (VKPipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKIndexBuffer_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKIndexBuffer_resourceId_get" "', argument " "1"" of type '" "VKPipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::IndexBuffer * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKIndexBuffer_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::IndexBuffer *arg1 = (VKPipe::IndexBuffer *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKIndexBuffer_byteOffset_set" "', argument " "1"" of type '" "VKPipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::IndexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKIndexBuffer_byteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKIndexBuffer_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::IndexBuffer *arg1 = (VKPipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKIndexBuffer_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKIndexBuffer_byteOffset_get" "', argument " "1"" of type '" "VKPipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::IndexBuffer * >(argp1);
  result = (uint64_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKIndexBuffer_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::IndexBuffer *arg1 = (VKPipe::IndexBuffer *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKIndexBuffer_byteSize_set" "', argument " "1"" of type '" "VKPipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::IndexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKIndexBuffer_byteSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKIndexBuffer_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::IndexBuffer *arg1 = (VKPipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKIndexBuffer_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKIndexBuffer_byteSize_get" "', argument " "1"" of type '" "VKPipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::IndexBuffer * >(argp1);
  result = (uint64_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKIndexBuffer_byteStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::IndexBuffer *arg1 = (VKPipe::IndexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKIndexBuffer_byteStride_set" "', argument " "1"" of type '" "VKPipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::IndexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKIndexBuffer_byteStride_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKIndexBuffer_byteStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::IndexBuffer *arg1 = (VKPipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKIndexBuffer_byteStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKIndexBuffer_byteStride_get" "', argument " "1"" of type '" "VKPipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::IndexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteStride);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKIndexBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::IndexBuffer *arg1 = (VKPipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKIndexBuffer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__IndexBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKIndexBuffer" "', argument " "1"" of type '" "VKPipe::IndexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::IndexBuffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKIndexBuffer) /* defines _wrap_delete_VKIndexBuffer_destructor_closure */

SWIGINTERN int _wrap_new_VKInputAssembly__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::InputAssembly *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::InputAssembly *)new VKPipe::InputAssembly();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__InputAssembly, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKInputAssembly__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::InputAssembly *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::InputAssembly *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__InputAssembly,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKInputAssembly" "', argument " "1"" of type '" "VKPipe::InputAssembly const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKInputAssembly" "', argument " "1"" of type '" "VKPipe::InputAssembly const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::InputAssembly * >(argp1);
  result = (VKPipe::InputAssembly *)new VKPipe::InputAssembly((VKPipe::InputAssembly const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__InputAssembly, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKInputAssembly(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKInputAssembly",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKInputAssembly__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKInputAssembly__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKInputAssembly'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::InputAssembly::InputAssembly()\n"
    "    VKPipe::InputAssembly::InputAssembly(VKPipe::InputAssembly const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKInputAssembly_primitiveRestartEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::InputAssembly *arg1 = (VKPipe::InputAssembly *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKInputAssembly_primitiveRestartEnable_set" "', argument " "1"" of type '" "VKPipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::InputAssembly * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKInputAssembly_primitiveRestartEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->primitiveRestartEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKInputAssembly_primitiveRestartEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::InputAssembly *arg1 = (VKPipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKInputAssembly_primitiveRestartEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKInputAssembly_primitiveRestartEnable_get" "', argument " "1"" of type '" "VKPipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::InputAssembly * >(argp1);
  result = (bool) ((arg1)->primitiveRestartEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKInputAssembly_indexBuffer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::InputAssembly *arg1 = (VKPipe::InputAssembly *) 0 ;
  VKPipe::IndexBuffer *arg2 = (VKPipe::IndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKInputAssembly_indexBuffer_set" "', argument " "1"" of type '" "VKPipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::InputAssembly * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__IndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKInputAssembly_indexBuffer_set" "', argument " "2"" of type '" "VKPipe::IndexBuffer *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::IndexBuffer * >(argp2);
  if (arg1) (arg1)->indexBuffer = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKInputAssembly_indexBuffer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::InputAssembly *arg1 = (VKPipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::IndexBuffer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKInputAssembly_indexBuffer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKInputAssembly_indexBuffer_get" "', argument " "1"" of type '" "VKPipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::InputAssembly * >(argp1);
  result = (VKPipe::IndexBuffer *)& ((arg1)->indexBuffer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__IndexBuffer, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKInputAssembly_topology_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::InputAssembly *arg1 = (VKPipe::InputAssembly *) 0 ;
  Topology arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKInputAssembly_topology_set" "', argument " "1"" of type '" "VKPipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::InputAssembly * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKInputAssembly_topology_set" "', argument " "2"" of type '" "Topology""'");
  } 
  arg2 = static_cast< Topology >(val2);
  if (arg1) (arg1)->topology = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKInputAssembly_topology_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::InputAssembly *arg1 = (VKPipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Topology result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKInputAssembly_topology_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKInputAssembly_topology_get" "', argument " "1"" of type '" "VKPipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::InputAssembly * >(argp1);
  result = (Topology) ((arg1)->topology);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_Topology->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKInputAssembly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::InputAssembly *arg1 = (VKPipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKInputAssembly",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__InputAssembly, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKInputAssembly" "', argument " "1"" of type '" "VKPipe::InputAssembly *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::InputAssembly * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKInputAssembly) /* defines _wrap_delete_VKInputAssembly_destructor_closure */

SWIGINTERN int _wrap_new_VKVertexAttribute__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::VertexAttribute *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::VertexAttribute *)new VKPipe::VertexAttribute();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__VertexAttribute, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKVertexAttribute__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::VertexAttribute *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::VertexAttribute *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__VertexAttribute,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKVertexAttribute" "', argument " "1"" of type '" "VKPipe::VertexAttribute const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKVertexAttribute" "', argument " "1"" of type '" "VKPipe::VertexAttribute const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexAttribute * >(argp1);
  result = (VKPipe::VertexAttribute *)new VKPipe::VertexAttribute((VKPipe::VertexAttribute const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__VertexAttribute, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKVertexAttribute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKVertexAttribute",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKVertexAttribute__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKVertexAttribute__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKVertexAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::VertexAttribute::VertexAttribute()\n"
    "    VKPipe::VertexAttribute::VertexAttribute(VKPipe::VertexAttribute const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKVertexAttribute___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexAttribute *arg1 = (VKPipe::VertexAttribute *) 0 ;
  VKPipe::VertexAttribute *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexAttribute___eq__" "', argument " "1"" of type '" "VKPipe::VertexAttribute const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__VertexAttribute,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKVertexAttribute___eq__" "', argument " "2"" of type '" "VKPipe::VertexAttribute const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKVertexAttribute___eq__" "', argument " "2"" of type '" "VKPipe::VertexAttribute const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::VertexAttribute * >(argp2);
  result = (bool)((VKPipe::VertexAttribute const *)arg1)->operator ==((VKPipe::VertexAttribute const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexAttribute___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexAttribute *arg1 = (VKPipe::VertexAttribute *) 0 ;
  VKPipe::VertexAttribute *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexAttribute___lt__" "', argument " "1"" of type '" "VKPipe::VertexAttribute const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__VertexAttribute,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKVertexAttribute___lt__" "', argument " "2"" of type '" "VKPipe::VertexAttribute const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKVertexAttribute___lt__" "', argument " "2"" of type '" "VKPipe::VertexAttribute const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::VertexAttribute * >(argp2);
  result = (bool)((VKPipe::VertexAttribute const *)arg1)->operator <((VKPipe::VertexAttribute const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexAttribute_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexAttribute *arg1 = (VKPipe::VertexAttribute *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexAttribute_location_set" "', argument " "1"" of type '" "VKPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexAttribute * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKVertexAttribute_location_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexAttribute_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexAttribute *arg1 = (VKPipe::VertexAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexAttribute_location_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexAttribute_location_get" "', argument " "1"" of type '" "VKPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexAttribute * >(argp1);
  result = (uint32_t) ((arg1)->location);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexAttribute_binding_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexAttribute *arg1 = (VKPipe::VertexAttribute *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexAttribute_binding_set" "', argument " "1"" of type '" "VKPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexAttribute * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKVertexAttribute_binding_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->binding = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexAttribute_binding_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexAttribute *arg1 = (VKPipe::VertexAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexAttribute_binding_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexAttribute_binding_get" "', argument " "1"" of type '" "VKPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexAttribute * >(argp1);
  result = (uint32_t) ((arg1)->binding);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexAttribute_format_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexAttribute *arg1 = (VKPipe::VertexAttribute *) 0 ;
  ResourceFormat *arg2 = (ResourceFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexAttribute_format_set" "', argument " "1"" of type '" "VKPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKVertexAttribute_format_set" "', argument " "2"" of type '" "ResourceFormat *""'"); 
  }
  arg2 = reinterpret_cast< ResourceFormat * >(argp2);
  if (arg1) (arg1)->format = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexAttribute_format_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexAttribute *arg1 = (VKPipe::VertexAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceFormat *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexAttribute_format_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexAttribute_format_get" "', argument " "1"" of type '" "VKPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexAttribute * >(argp1);
  result = (ResourceFormat *)& ((arg1)->format);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceFormat, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexAttribute_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexAttribute *arg1 = (VKPipe::VertexAttribute *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexAttribute_byteOffset_set" "', argument " "1"" of type '" "VKPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexAttribute * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKVertexAttribute_byteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexAttribute_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexAttribute *arg1 = (VKPipe::VertexAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexAttribute_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexAttribute_byteOffset_get" "', argument " "1"" of type '" "VKPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexAttribute * >(argp1);
  result = (uint32_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKVertexAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexAttribute *arg1 = (VKPipe::VertexAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKVertexAttribute",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKVertexAttribute" "', argument " "1"" of type '" "VKPipe::VertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexAttribute * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKVertexAttribute) /* defines _wrap_delete_VKVertexAttribute_destructor_closure */

SWIGINTERN int _wrap_new_VKVertexBinding__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::VertexBinding *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::VertexBinding *)new VKPipe::VertexBinding();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__VertexBinding, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKVertexBinding__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::VertexBinding *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::VertexBinding *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__VertexBinding,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKVertexBinding" "', argument " "1"" of type '" "VKPipe::VertexBinding const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKVertexBinding" "', argument " "1"" of type '" "VKPipe::VertexBinding const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBinding * >(argp1);
  result = (VKPipe::VertexBinding *)new VKPipe::VertexBinding((VKPipe::VertexBinding const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__VertexBinding, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKVertexBinding(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKVertexBinding",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKVertexBinding__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKVertexBinding__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKVertexBinding'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::VertexBinding::VertexBinding()\n"
    "    VKPipe::VertexBinding::VertexBinding(VKPipe::VertexBinding const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKVertexBinding___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBinding *arg1 = (VKPipe::VertexBinding *) 0 ;
  VKPipe::VertexBinding *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBinding___eq__" "', argument " "1"" of type '" "VKPipe::VertexBinding const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__VertexBinding,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKVertexBinding___eq__" "', argument " "2"" of type '" "VKPipe::VertexBinding const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKVertexBinding___eq__" "', argument " "2"" of type '" "VKPipe::VertexBinding const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::VertexBinding * >(argp2);
  result = (bool)((VKPipe::VertexBinding const *)arg1)->operator ==((VKPipe::VertexBinding const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBinding___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBinding *arg1 = (VKPipe::VertexBinding *) 0 ;
  VKPipe::VertexBinding *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBinding___lt__" "', argument " "1"" of type '" "VKPipe::VertexBinding const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__VertexBinding,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKVertexBinding___lt__" "', argument " "2"" of type '" "VKPipe::VertexBinding const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKVertexBinding___lt__" "', argument " "2"" of type '" "VKPipe::VertexBinding const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::VertexBinding * >(argp2);
  result = (bool)((VKPipe::VertexBinding const *)arg1)->operator <((VKPipe::VertexBinding const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBinding_vertexBufferBinding_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBinding *arg1 = (VKPipe::VertexBinding *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBinding_vertexBufferBinding_set" "', argument " "1"" of type '" "VKPipe::VertexBinding *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBinding * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKVertexBinding_vertexBufferBinding_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->vertexBufferBinding = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBinding_vertexBufferBinding_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBinding *arg1 = (VKPipe::VertexBinding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexBinding_vertexBufferBinding_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBinding_vertexBufferBinding_get" "', argument " "1"" of type '" "VKPipe::VertexBinding *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBinding * >(argp1);
  result = (uint32_t) ((arg1)->vertexBufferBinding);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBinding_perInstance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBinding *arg1 = (VKPipe::VertexBinding *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBinding_perInstance_set" "', argument " "1"" of type '" "VKPipe::VertexBinding *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBinding * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKVertexBinding_perInstance_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->perInstance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBinding_perInstance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBinding *arg1 = (VKPipe::VertexBinding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexBinding_perInstance_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBinding_perInstance_get" "', argument " "1"" of type '" "VKPipe::VertexBinding *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBinding * >(argp1);
  result = (bool) ((arg1)->perInstance);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBinding_instanceDivisor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBinding *arg1 = (VKPipe::VertexBinding *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBinding_instanceDivisor_set" "', argument " "1"" of type '" "VKPipe::VertexBinding *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBinding * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKVertexBinding_instanceDivisor_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->instanceDivisor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBinding_instanceDivisor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBinding *arg1 = (VKPipe::VertexBinding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexBinding_instanceDivisor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBinding_instanceDivisor_get" "', argument " "1"" of type '" "VKPipe::VertexBinding *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBinding * >(argp1);
  result = (uint32_t) ((arg1)->instanceDivisor);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKVertexBinding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBinding *arg1 = (VKPipe::VertexBinding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKVertexBinding",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBinding, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKVertexBinding" "', argument " "1"" of type '" "VKPipe::VertexBinding *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBinding * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKVertexBinding) /* defines _wrap_delete_VKVertexBinding_destructor_closure */

SWIGINTERN int _wrap_new_VKVertexBuffer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::VertexBuffer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::VertexBuffer *)new VKPipe::VertexBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__VertexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKVertexBuffer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::VertexBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::VertexBuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKVertexBuffer" "', argument " "1"" of type '" "VKPipe::VertexBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKVertexBuffer" "', argument " "1"" of type '" "VKPipe::VertexBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBuffer * >(argp1);
  result = (VKPipe::VertexBuffer *)new VKPipe::VertexBuffer((VKPipe::VertexBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__VertexBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKVertexBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKVertexBuffer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKVertexBuffer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKVertexBuffer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKVertexBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::VertexBuffer::VertexBuffer()\n"
    "    VKPipe::VertexBuffer::VertexBuffer(VKPipe::VertexBuffer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKVertexBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBuffer *arg1 = (VKPipe::VertexBuffer *) 0 ;
  VKPipe::VertexBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBuffer___eq__" "', argument " "1"" of type '" "VKPipe::VertexBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKVertexBuffer___eq__" "', argument " "2"" of type '" "VKPipe::VertexBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKVertexBuffer___eq__" "', argument " "2"" of type '" "VKPipe::VertexBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::VertexBuffer * >(argp2);
  result = (bool)((VKPipe::VertexBuffer const *)arg1)->operator ==((VKPipe::VertexBuffer const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBuffer *arg1 = (VKPipe::VertexBuffer *) 0 ;
  VKPipe::VertexBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBuffer___lt__" "', argument " "1"" of type '" "VKPipe::VertexBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKVertexBuffer___lt__" "', argument " "2"" of type '" "VKPipe::VertexBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKVertexBuffer___lt__" "', argument " "2"" of type '" "VKPipe::VertexBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::VertexBuffer * >(argp2);
  result = (bool)((VKPipe::VertexBuffer const *)arg1)->operator <((VKPipe::VertexBuffer const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBuffer_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBuffer *arg1 = (VKPipe::VertexBuffer *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBuffer_resourceId_set" "', argument " "1"" of type '" "VKPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKVertexBuffer_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBuffer_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBuffer *arg1 = (VKPipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexBuffer_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBuffer_resourceId_get" "', argument " "1"" of type '" "VKPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBuffer * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBuffer_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBuffer *arg1 = (VKPipe::VertexBuffer *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBuffer_byteOffset_set" "', argument " "1"" of type '" "VKPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKVertexBuffer_byteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBuffer_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBuffer *arg1 = (VKPipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexBuffer_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBuffer_byteOffset_get" "', argument " "1"" of type '" "VKPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBuffer * >(argp1);
  result = (uint64_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBuffer_byteStride_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBuffer *arg1 = (VKPipe::VertexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBuffer_byteStride_set" "', argument " "1"" of type '" "VKPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKVertexBuffer_byteStride_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteStride = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBuffer_byteStride_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBuffer *arg1 = (VKPipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexBuffer_byteStride_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBuffer_byteStride_get" "', argument " "1"" of type '" "VKPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteStride);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBuffer_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBuffer *arg1 = (VKPipe::VertexBuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBuffer_byteSize_set" "', argument " "1"" of type '" "VKPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKVertexBuffer_byteSize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexBuffer_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBuffer *arg1 = (VKPipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexBuffer_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexBuffer_byteSize_get" "', argument " "1"" of type '" "VKPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBuffer * >(argp1);
  result = (uint32_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKVertexBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexBuffer *arg1 = (VKPipe::VertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKVertexBuffer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKVertexBuffer" "', argument " "1"" of type '" "VKPipe::VertexBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexBuffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKVertexBuffer) /* defines _wrap_delete_VKVertexBuffer_destructor_closure */

SWIGINTERN int _wrap_new_VKVertexInput__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::VertexInput *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::VertexInput *)new VKPipe::VertexInput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__VertexInput, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKVertexInput__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::VertexInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::VertexInput *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__VertexInput,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKVertexInput" "', argument " "1"" of type '" "VKPipe::VertexInput const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKVertexInput" "', argument " "1"" of type '" "VKPipe::VertexInput const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexInput * >(argp1);
  result = (VKPipe::VertexInput *)new VKPipe::VertexInput((VKPipe::VertexInput const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__VertexInput, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKVertexInput(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKVertexInput",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKVertexInput__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKVertexInput__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKVertexInput'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::VertexInput::VertexInput()\n"
    "    VKPipe::VertexInput::VertexInput(VKPipe::VertexInput const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKVertexInput_attributes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexInput *arg1 = (VKPipe::VertexInput *) 0 ;
  rdcarray< VKPipe::VertexAttribute > *arg2 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexInput_attributes_set" "', argument " "1"" of type '" "VKPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexInput * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKVertexInput_attributes_set' argument 2 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKVertexInput_attributes_set' argument 2 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->attributes = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexInput_attributes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexInput *arg1 = (VKPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< VKPipe::VertexAttribute > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexInput_attributes_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexInput_attributes_get" "', argument " "1"" of type '" "VKPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexInput * >(argp1);
  result = (rdcarray< VKPipe::VertexAttribute > *)& ((arg1)->attributes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_VKPipe__VertexAttribute_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexInput_bindings_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexInput *arg1 = (VKPipe::VertexInput *) 0 ;
  rdcarray< VKPipe::VertexBinding > *arg2 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexInput_bindings_set" "', argument " "1"" of type '" "VKPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexInput * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKVertexInput_bindings_set' argument 2 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKVertexInput_bindings_set' argument 2 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->bindings = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexInput_bindings_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexInput *arg1 = (VKPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< VKPipe::VertexBinding > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexInput_bindings_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexInput_bindings_get" "', argument " "1"" of type '" "VKPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexInput * >(argp1);
  result = (rdcarray< VKPipe::VertexBinding > *)& ((arg1)->bindings);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_VKPipe__VertexBinding_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexInput_vertexBuffers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexInput *arg1 = (VKPipe::VertexInput *) 0 ;
  rdcarray< VKPipe::VertexBuffer > *arg2 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexInput_vertexBuffers_set" "', argument " "1"" of type '" "VKPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexInput * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKVertexInput_vertexBuffers_set' argument 2 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKVertexInput_vertexBuffers_set' argument 2 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->vertexBuffers = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKVertexInput_vertexBuffers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexInput *arg1 = (VKPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< VKPipe::VertexBuffer > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKVertexInput_vertexBuffers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKVertexInput_vertexBuffers_get" "', argument " "1"" of type '" "VKPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexInput * >(argp1);
  result = (rdcarray< VKPipe::VertexBuffer > *)& ((arg1)->vertexBuffers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_VKPipe__VertexBuffer_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKVertexInput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::VertexInput *arg1 = (VKPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKVertexInput",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__VertexInput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKVertexInput" "', argument " "1"" of type '" "VKPipe::VertexInput *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::VertexInput * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKVertexInput) /* defines _wrap_delete_VKVertexInput_destructor_closure */

SWIGINTERN int _wrap_new_VKShader__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::Shader *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::Shader *)new VKPipe::Shader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Shader, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKShader__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::Shader *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__Shader,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKShader" "', argument " "1"" of type '" "VKPipe::Shader const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKShader" "', argument " "1"" of type '" "VKPipe::Shader const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  result = (VKPipe::Shader *)new VKPipe::Shader((VKPipe::Shader const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Shader, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKShader(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKShader",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKShader__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKShader__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKShader'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::Shader::Shader()\n"
    "    VKPipe::Shader::Shader(VKPipe::Shader const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKShader_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_resourceId_set" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKShader_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKShader_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_resourceId_get" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_entryPoint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_entryPoint_set" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKShader_entryPoint_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->entryPoint = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_entryPoint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKShader_entryPoint_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_entryPoint_get" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  result =  ((arg1)->entryPoint);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_reflection_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  ShaderReflection *arg2 = (ShaderReflection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_reflection_set" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ShaderReflection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKShader_reflection_set" "', argument " "2"" of type '" "ShaderReflection const *""'"); 
  }
  arg2 = reinterpret_cast< ShaderReflection * >(argp2);
  if (arg1) (arg1)->reflection = (ShaderReflection const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_reflection_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderReflection *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKShader_reflection_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_reflection_get" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  result = (ShaderReflection *) ((arg1)->reflection);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderReflection, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_stage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_stage_set" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKShader_stage_set" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  if (arg1) (arg1)->stage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_stage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ShaderStage result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKShader_stage_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_stage_get" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  result = (ShaderStage) ((arg1)->stage);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ShaderStage->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_pushConstantRangeByteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_pushConstantRangeByteOffset_set" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKShader_pushConstantRangeByteOffset_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->pushConstantRangeByteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_pushConstantRangeByteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKShader_pushConstantRangeByteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_pushConstantRangeByteOffset_get" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  result = (uint32_t) ((arg1)->pushConstantRangeByteOffset);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_pushConstantRangeByteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_pushConstantRangeByteSize_set" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKShader_pushConstantRangeByteSize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->pushConstantRangeByteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_pushConstantRangeByteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKShader_pushConstantRangeByteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_pushConstantRangeByteSize_get" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  result = (uint32_t) ((arg1)->pushConstantRangeByteSize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_requiredSubgroupSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_requiredSubgroupSize_set" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKShader_requiredSubgroupSize_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->requiredSubgroupSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_requiredSubgroupSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKShader_requiredSubgroupSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_requiredSubgroupSize_get" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  result = (uint32_t) ((arg1)->requiredSubgroupSize);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_specializationData_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  bytebuf *arg2 = (bytebuf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bytebuf temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_specializationData_set" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKShader_specializationData_set' argument 2 of type 'bytebuf'"); 
    }
  }
  if (arg1) (arg1)->specializationData = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_specializationData_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bytebuf *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKShader_specializationData_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_specializationData_get" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  result = (bytebuf *)& ((arg1)->specializationData);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_specializationIds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_specializationIds_set" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKShader_specializationIds_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKShader_specializationIds_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->specializationIds = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_specializationIds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKShader_specializationIds_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_specializationIds_get" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->specializationIds);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_shaderObject_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_shaderObject_set" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKShader_shaderObject_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->shaderObject = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKShader_shaderObject_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKShader_shaderObject_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKShader_shaderObject_get" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  result = (bool) ((arg1)->shaderObject);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKShader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Shader *arg1 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKShader",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Shader, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKShader" "', argument " "1"" of type '" "VKPipe::Shader *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Shader * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKShader) /* defines _wrap_delete_VKShader_destructor_closure */

SWIGINTERN int _wrap_new_VKTessellation__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::Tessellation *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::Tessellation *)new VKPipe::Tessellation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Tessellation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKTessellation__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::Tessellation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::Tessellation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__Tessellation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKTessellation" "', argument " "1"" of type '" "VKPipe::Tessellation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKTessellation" "', argument " "1"" of type '" "VKPipe::Tessellation const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Tessellation * >(argp1);
  result = (VKPipe::Tessellation *)new VKPipe::Tessellation((VKPipe::Tessellation const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Tessellation, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKTessellation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKTessellation",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKTessellation__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKTessellation__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKTessellation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::Tessellation::Tessellation()\n"
    "    VKPipe::Tessellation::Tessellation(VKPipe::Tessellation const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKTessellation_numControlPoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Tessellation *arg1 = (VKPipe::Tessellation *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Tessellation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKTessellation_numControlPoints_set" "', argument " "1"" of type '" "VKPipe::Tessellation *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Tessellation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKTessellation_numControlPoints_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->numControlPoints = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKTessellation_numControlPoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Tessellation *arg1 = (VKPipe::Tessellation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKTessellation_numControlPoints_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Tessellation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKTessellation_numControlPoints_get" "', argument " "1"" of type '" "VKPipe::Tessellation *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Tessellation * >(argp1);
  result = (uint32_t) ((arg1)->numControlPoints);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKTessellation_domainOriginUpperLeft_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Tessellation *arg1 = (VKPipe::Tessellation *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Tessellation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKTessellation_domainOriginUpperLeft_set" "', argument " "1"" of type '" "VKPipe::Tessellation *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Tessellation * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKTessellation_domainOriginUpperLeft_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->domainOriginUpperLeft = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKTessellation_domainOriginUpperLeft_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Tessellation *arg1 = (VKPipe::Tessellation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKTessellation_domainOriginUpperLeft_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Tessellation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKTessellation_domainOriginUpperLeft_get" "', argument " "1"" of type '" "VKPipe::Tessellation *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Tessellation * >(argp1);
  result = (bool) ((arg1)->domainOriginUpperLeft);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKTessellation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Tessellation *arg1 = (VKPipe::Tessellation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKTessellation",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Tessellation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKTessellation" "', argument " "1"" of type '" "VKPipe::Tessellation *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Tessellation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKTessellation) /* defines _wrap_delete_VKTessellation_destructor_closure */

SWIGINTERN int _wrap_new_VKXFBBuffer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::XFBBuffer *)new VKPipe::XFBBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__XFBBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKXFBBuffer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::XFBBuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__XFBBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKXFBBuffer" "', argument " "1"" of type '" "VKPipe::XFBBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKXFBBuffer" "', argument " "1"" of type '" "VKPipe::XFBBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  result = (VKPipe::XFBBuffer *)new VKPipe::XFBBuffer((VKPipe::XFBBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__XFBBuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKXFBBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKXFBBuffer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKXFBBuffer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKXFBBuffer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKXFBBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::XFBBuffer::XFBBuffer()\n"
    "    VKPipe::XFBBuffer::XFBBuffer(VKPipe::XFBBuffer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  VKPipe::XFBBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer___eq__" "', argument " "1"" of type '" "VKPipe::XFBBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__XFBBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKXFBBuffer___eq__" "', argument " "2"" of type '" "VKPipe::XFBBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKXFBBuffer___eq__" "', argument " "2"" of type '" "VKPipe::XFBBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::XFBBuffer * >(argp2);
  result = (bool)((VKPipe::XFBBuffer const *)arg1)->operator ==((VKPipe::XFBBuffer const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  VKPipe::XFBBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer___lt__" "', argument " "1"" of type '" "VKPipe::XFBBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__XFBBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKXFBBuffer___lt__" "', argument " "2"" of type '" "VKPipe::XFBBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKXFBBuffer___lt__" "', argument " "2"" of type '" "VKPipe::XFBBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::XFBBuffer * >(argp2);
  result = (bool)((VKPipe::XFBBuffer const *)arg1)->operator <((VKPipe::XFBBuffer const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer_active_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer_active_set" "', argument " "1"" of type '" "VKPipe::XFBBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKXFBBuffer_active_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->active = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer_active_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKXFBBuffer_active_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer_active_get" "', argument " "1"" of type '" "VKPipe::XFBBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  result = (bool) ((arg1)->active);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer_bufferResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer_bufferResourceId_set" "', argument " "1"" of type '" "VKPipe::XFBBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKXFBBuffer_bufferResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->bufferResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer_bufferResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKXFBBuffer_bufferResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer_bufferResourceId_get" "', argument " "1"" of type '" "VKPipe::XFBBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  result = (ResourceId *)& ((arg1)->bufferResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer_byteOffset_set" "', argument " "1"" of type '" "VKPipe::XFBBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKXFBBuffer_byteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKXFBBuffer_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer_byteOffset_get" "', argument " "1"" of type '" "VKPipe::XFBBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  result = (uint64_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer_byteSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer_byteSize_set" "', argument " "1"" of type '" "VKPipe::XFBBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKXFBBuffer_byteSize_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer_byteSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKXFBBuffer_byteSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer_byteSize_get" "', argument " "1"" of type '" "VKPipe::XFBBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  result = (uint64_t) ((arg1)->byteSize);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer_counterBufferResourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer_counterBufferResourceId_set" "', argument " "1"" of type '" "VKPipe::XFBBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKXFBBuffer_counterBufferResourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->counterBufferResourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer_counterBufferResourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKXFBBuffer_counterBufferResourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer_counterBufferResourceId_get" "', argument " "1"" of type '" "VKPipe::XFBBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  result = (ResourceId *)& ((arg1)->counterBufferResourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer_counterBufferOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer_counterBufferOffset_set" "', argument " "1"" of type '" "VKPipe::XFBBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKXFBBuffer_counterBufferOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->counterBufferOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKXFBBuffer_counterBufferOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKXFBBuffer_counterBufferOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKXFBBuffer_counterBufferOffset_get" "', argument " "1"" of type '" "VKPipe::XFBBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  result = (uint64_t) ((arg1)->counterBufferOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKXFBBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::XFBBuffer *arg1 = (VKPipe::XFBBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKXFBBuffer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__XFBBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKXFBBuffer" "', argument " "1"" of type '" "VKPipe::XFBBuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::XFBBuffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKXFBBuffer) /* defines _wrap_delete_VKXFBBuffer_destructor_closure */

SWIGINTERN int _wrap_new_VKTransformFeedback__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::TransformFeedback *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::TransformFeedback *)new VKPipe::TransformFeedback();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__TransformFeedback, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKTransformFeedback__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::TransformFeedback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::TransformFeedback *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__TransformFeedback,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKTransformFeedback" "', argument " "1"" of type '" "VKPipe::TransformFeedback const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKTransformFeedback" "', argument " "1"" of type '" "VKPipe::TransformFeedback const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::TransformFeedback * >(argp1);
  result = (VKPipe::TransformFeedback *)new VKPipe::TransformFeedback((VKPipe::TransformFeedback const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__TransformFeedback, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKTransformFeedback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKTransformFeedback",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKTransformFeedback__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKTransformFeedback__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKTransformFeedback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::TransformFeedback::TransformFeedback()\n"
    "    VKPipe::TransformFeedback::TransformFeedback(VKPipe::TransformFeedback const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKTransformFeedback_buffers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::TransformFeedback *arg1 = (VKPipe::TransformFeedback *) 0 ;
  rdcarray< VKPipe::XFBBuffer > *arg2 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__TransformFeedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKTransformFeedback_buffers_set" "', argument " "1"" of type '" "VKPipe::TransformFeedback *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::TransformFeedback * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKTransformFeedback_buffers_set' argument 2 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKTransformFeedback_buffers_set' argument 2 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->buffers = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKTransformFeedback_buffers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::TransformFeedback *arg1 = (VKPipe::TransformFeedback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< VKPipe::XFBBuffer > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKTransformFeedback_buffers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__TransformFeedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKTransformFeedback_buffers_get" "', argument " "1"" of type '" "VKPipe::TransformFeedback *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::TransformFeedback * >(argp1);
  result = (rdcarray< VKPipe::XFBBuffer > *)& ((arg1)->buffers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_VKPipe__XFBBuffer_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKTransformFeedback_rasterizedStream_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::TransformFeedback *arg1 = (VKPipe::TransformFeedback *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__TransformFeedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKTransformFeedback_rasterizedStream_set" "', argument " "1"" of type '" "VKPipe::TransformFeedback *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::TransformFeedback * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKTransformFeedback_rasterizedStream_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->rasterizedStream = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKTransformFeedback_rasterizedStream_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::TransformFeedback *arg1 = (VKPipe::TransformFeedback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKTransformFeedback_rasterizedStream_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__TransformFeedback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKTransformFeedback_rasterizedStream_get" "', argument " "1"" of type '" "VKPipe::TransformFeedback *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::TransformFeedback * >(argp1);
  result = (uint32_t) ((arg1)->rasterizedStream);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKTransformFeedback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::TransformFeedback *arg1 = (VKPipe::TransformFeedback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKTransformFeedback",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__TransformFeedback, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKTransformFeedback" "', argument " "1"" of type '" "VKPipe::TransformFeedback *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::TransformFeedback * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKTransformFeedback) /* defines _wrap_delete_VKTransformFeedback_destructor_closure */

SWIGINTERN int _wrap_new_VKRenderArea__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::RenderArea *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::RenderArea *)new VKPipe::RenderArea();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__RenderArea, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKRenderArea__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::RenderArea *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::RenderArea *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__RenderArea,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKRenderArea" "', argument " "1"" of type '" "VKPipe::RenderArea const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKRenderArea" "', argument " "1"" of type '" "VKPipe::RenderArea const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderArea * >(argp1);
  result = (VKPipe::RenderArea *)new VKPipe::RenderArea((VKPipe::RenderArea const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__RenderArea, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKRenderArea(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKRenderArea",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKRenderArea__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKRenderArea__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKRenderArea'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::RenderArea::RenderArea()\n"
    "    VKPipe::RenderArea::RenderArea(VKPipe::RenderArea const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKRenderArea___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderArea *arg1 = (VKPipe::RenderArea *) 0 ;
  VKPipe::RenderArea *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderArea___eq__" "', argument " "1"" of type '" "VKPipe::RenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderArea * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__RenderArea,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKRenderArea___eq__" "', argument " "2"" of type '" "VKPipe::RenderArea const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKRenderArea___eq__" "', argument " "2"" of type '" "VKPipe::RenderArea const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::RenderArea * >(argp2);
  result = (bool)((VKPipe::RenderArea const *)arg1)->operator ==((VKPipe::RenderArea const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderArea___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderArea *arg1 = (VKPipe::RenderArea *) 0 ;
  VKPipe::RenderArea *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderArea___lt__" "', argument " "1"" of type '" "VKPipe::RenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderArea * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__RenderArea,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKRenderArea___lt__" "', argument " "2"" of type '" "VKPipe::RenderArea const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKRenderArea___lt__" "', argument " "2"" of type '" "VKPipe::RenderArea const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::RenderArea * >(argp2);
  result = (bool)((VKPipe::RenderArea const *)arg1)->operator <((VKPipe::RenderArea const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderArea_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderArea *arg1 = (VKPipe::RenderArea *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderArea_x_set" "', argument " "1"" of type '" "VKPipe::RenderArea *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderArea_x_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderArea_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderArea *arg1 = (VKPipe::RenderArea *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderArea_x_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderArea_x_get" "', argument " "1"" of type '" "VKPipe::RenderArea *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderArea * >(argp1);
  result = (int32_t) ((arg1)->x);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderArea_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderArea *arg1 = (VKPipe::RenderArea *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderArea_y_set" "', argument " "1"" of type '" "VKPipe::RenderArea *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderArea_y_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderArea_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderArea *arg1 = (VKPipe::RenderArea *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderArea_y_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderArea_y_get" "', argument " "1"" of type '" "VKPipe::RenderArea *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderArea * >(argp1);
  result = (int32_t) ((arg1)->y);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderArea_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderArea *arg1 = (VKPipe::RenderArea *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderArea_width_set" "', argument " "1"" of type '" "VKPipe::RenderArea *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderArea_width_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderArea_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderArea *arg1 = (VKPipe::RenderArea *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderArea_width_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderArea_width_get" "', argument " "1"" of type '" "VKPipe::RenderArea *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderArea * >(argp1);
  result = (int32_t) ((arg1)->width);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderArea_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderArea *arg1 = (VKPipe::RenderArea *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderArea_height_set" "', argument " "1"" of type '" "VKPipe::RenderArea *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderArea_height_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderArea_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderArea *arg1 = (VKPipe::RenderArea *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderArea_height_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderArea_height_get" "', argument " "1"" of type '" "VKPipe::RenderArea *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderArea * >(argp1);
  result = (int32_t) ((arg1)->height);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKRenderArea(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderArea *arg1 = (VKPipe::RenderArea *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKRenderArea",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderArea, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKRenderArea" "', argument " "1"" of type '" "VKPipe::RenderArea *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderArea * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKRenderArea) /* defines _wrap_delete_VKRenderArea_destructor_closure */

SWIGINTERN int _wrap_new_VKViewportScissor__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::ViewportScissor *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::ViewportScissor *)new VKPipe::ViewportScissor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ViewportScissor, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKViewportScissor__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::ViewportScissor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::ViewportScissor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__ViewportScissor,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKViewportScissor" "', argument " "1"" of type '" "VKPipe::ViewportScissor const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKViewportScissor" "', argument " "1"" of type '" "VKPipe::ViewportScissor const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewportScissor * >(argp1);
  result = (VKPipe::ViewportScissor *)new VKPipe::ViewportScissor((VKPipe::ViewportScissor const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ViewportScissor, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKViewportScissor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKViewportScissor",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKViewportScissor__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKViewportScissor__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKViewportScissor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::ViewportScissor::ViewportScissor()\n"
    "    VKPipe::ViewportScissor::ViewportScissor(VKPipe::ViewportScissor const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKViewportScissor___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewportScissor *arg1 = (VKPipe::ViewportScissor *) 0 ;
  VKPipe::ViewportScissor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewportScissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewportScissor___eq__" "', argument " "1"" of type '" "VKPipe::ViewportScissor const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewportScissor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__ViewportScissor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKViewportScissor___eq__" "', argument " "2"" of type '" "VKPipe::ViewportScissor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKViewportScissor___eq__" "', argument " "2"" of type '" "VKPipe::ViewportScissor const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::ViewportScissor * >(argp2);
  result = (bool)((VKPipe::ViewportScissor const *)arg1)->operator ==((VKPipe::ViewportScissor const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKViewportScissor___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewportScissor *arg1 = (VKPipe::ViewportScissor *) 0 ;
  VKPipe::ViewportScissor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewportScissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewportScissor___lt__" "', argument " "1"" of type '" "VKPipe::ViewportScissor const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewportScissor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__ViewportScissor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKViewportScissor___lt__" "', argument " "2"" of type '" "VKPipe::ViewportScissor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKViewportScissor___lt__" "', argument " "2"" of type '" "VKPipe::ViewportScissor const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::ViewportScissor * >(argp2);
  result = (bool)((VKPipe::ViewportScissor const *)arg1)->operator <((VKPipe::ViewportScissor const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKViewportScissor_vp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewportScissor *arg1 = (VKPipe::ViewportScissor *) 0 ;
  Viewport *arg2 = (Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewportScissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewportScissor_vp_set" "', argument " "1"" of type '" "VKPipe::ViewportScissor *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewportScissor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKViewportScissor_vp_set" "', argument " "2"" of type '" "Viewport *""'"); 
  }
  arg2 = reinterpret_cast< Viewport * >(argp2);
  if (arg1) (arg1)->vp = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKViewportScissor_vp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewportScissor *arg1 = (VKPipe::ViewportScissor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Viewport *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKViewportScissor_vp_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewportScissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewportScissor_vp_get" "', argument " "1"" of type '" "VKPipe::ViewportScissor *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewportScissor * >(argp1);
  result = (Viewport *)& ((arg1)->vp);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Viewport, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKViewportScissor_scissor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewportScissor *arg1 = (VKPipe::ViewportScissor *) 0 ;
  Scissor *arg2 = (Scissor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewportScissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewportScissor_scissor_set" "', argument " "1"" of type '" "VKPipe::ViewportScissor *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewportScissor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_Scissor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKViewportScissor_scissor_set" "', argument " "2"" of type '" "Scissor *""'"); 
  }
  arg2 = reinterpret_cast< Scissor * >(argp2);
  if (arg1) (arg1)->scissor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKViewportScissor_scissor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewportScissor *arg1 = (VKPipe::ViewportScissor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Scissor *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKViewportScissor_scissor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewportScissor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewportScissor_scissor_get" "', argument " "1"" of type '" "VKPipe::ViewportScissor *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewportScissor * >(argp1);
  result = (Scissor *)& ((arg1)->scissor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Scissor, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKViewportScissor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewportScissor *arg1 = (VKPipe::ViewportScissor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKViewportScissor",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewportScissor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKViewportScissor" "', argument " "1"" of type '" "VKPipe::ViewportScissor *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewportScissor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKViewportScissor) /* defines _wrap_delete_VKViewportScissor_destructor_closure */

SWIGINTERN int _wrap_new_VKViewState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::ViewState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::ViewState *)new VKPipe::ViewState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ViewState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKViewState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::ViewState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::ViewState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__ViewState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKViewState" "', argument " "1"" of type '" "VKPipe::ViewState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKViewState" "', argument " "1"" of type '" "VKPipe::ViewState const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewState * >(argp1);
  result = (VKPipe::ViewState *)new VKPipe::ViewState((VKPipe::ViewState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ViewState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKViewState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKViewState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKViewState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKViewState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKViewState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::ViewState::ViewState()\n"
    "    VKPipe::ViewState::ViewState(VKPipe::ViewState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKViewState_viewportScissors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewState *arg1 = (VKPipe::ViewState *) 0 ;
  rdcarray< VKPipe::ViewportScissor > *arg2 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewState_viewportScissors_set" "', argument " "1"" of type '" "VKPipe::ViewState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewState * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKViewState_viewportScissors_set' argument 2 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKViewState_viewportScissors_set' argument 2 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->viewportScissors = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKViewState_viewportScissors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewState *arg1 = (VKPipe::ViewState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< VKPipe::ViewportScissor > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKViewState_viewportScissors_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewState_viewportScissors_get" "', argument " "1"" of type '" "VKPipe::ViewState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewState * >(argp1);
  result = (rdcarray< VKPipe::ViewportScissor > *)& ((arg1)->viewportScissors);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_VKPipe__ViewportScissor_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKViewState_discardRectangles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewState *arg1 = (VKPipe::ViewState *) 0 ;
  rdcarray< VKPipe::RenderArea > *arg2 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewState_discardRectangles_set" "', argument " "1"" of type '" "VKPipe::ViewState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewState * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKViewState_discardRectangles_set' argument 2 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKViewState_discardRectangles_set' argument 2 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->discardRectangles = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKViewState_discardRectangles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewState *arg1 = (VKPipe::ViewState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< VKPipe::RenderArea > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKViewState_discardRectangles_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewState_discardRectangles_get" "', argument " "1"" of type '" "VKPipe::ViewState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewState * >(argp1);
  result = (rdcarray< VKPipe::RenderArea > *)& ((arg1)->discardRectangles);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_VKPipe__RenderArea_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKViewState_discardRectanglesExclusive_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewState *arg1 = (VKPipe::ViewState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewState_discardRectanglesExclusive_set" "', argument " "1"" of type '" "VKPipe::ViewState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKViewState_discardRectanglesExclusive_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->discardRectanglesExclusive = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKViewState_discardRectanglesExclusive_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewState *arg1 = (VKPipe::ViewState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKViewState_discardRectanglesExclusive_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewState_discardRectanglesExclusive_get" "', argument " "1"" of type '" "VKPipe::ViewState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewState * >(argp1);
  result = (bool) ((arg1)->discardRectanglesExclusive);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKViewState_depthNegativeOneToOne_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewState *arg1 = (VKPipe::ViewState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewState_depthNegativeOneToOne_set" "', argument " "1"" of type '" "VKPipe::ViewState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKViewState_depthNegativeOneToOne_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthNegativeOneToOne = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKViewState_depthNegativeOneToOne_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewState *arg1 = (VKPipe::ViewState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKViewState_depthNegativeOneToOne_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKViewState_depthNegativeOneToOne_get" "', argument " "1"" of type '" "VKPipe::ViewState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewState * >(argp1);
  result = (bool) ((arg1)->depthNegativeOneToOne);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKViewState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ViewState *arg1 = (VKPipe::ViewState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKViewState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ViewState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKViewState" "', argument " "1"" of type '" "VKPipe::ViewState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ViewState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKViewState) /* defines _wrap_delete_VKViewState_destructor_closure */

SWIGINTERN int _wrap_new_VKRasterizer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::Rasterizer *)new VKPipe::Rasterizer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Rasterizer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKRasterizer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::Rasterizer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__Rasterizer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKRasterizer" "', argument " "1"" of type '" "VKPipe::Rasterizer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKRasterizer" "', argument " "1"" of type '" "VKPipe::Rasterizer const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (VKPipe::Rasterizer *)new VKPipe::Rasterizer((VKPipe::Rasterizer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Rasterizer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKRasterizer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKRasterizer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKRasterizer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKRasterizer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKRasterizer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::Rasterizer::Rasterizer()\n"
    "    VKPipe::Rasterizer::Rasterizer(VKPipe::Rasterizer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_depthClampEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_depthClampEnable_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_depthClampEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthClampEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_depthClampEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_depthClampEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_depthClampEnable_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (bool) ((arg1)->depthClampEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_depthClipEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_depthClipEnable_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_depthClipEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthClipEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_depthClipEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_depthClipEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_depthClipEnable_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (bool) ((arg1)->depthClipEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_rasterizerDiscardEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_rasterizerDiscardEnable_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_rasterizerDiscardEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->rasterizerDiscardEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_rasterizerDiscardEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_rasterizerDiscardEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_rasterizerDiscardEnable_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (bool) ((arg1)->rasterizerDiscardEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_frontCCW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_frontCCW_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_frontCCW_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->frontCCW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_frontCCW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_frontCCW_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_frontCCW_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (bool) ((arg1)->frontCCW);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_fillMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  FillMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_fillMode_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_fillMode_set" "', argument " "2"" of type '" "FillMode""'");
  } 
  arg2 = static_cast< FillMode >(val2);
  if (arg1) (arg1)->fillMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_fillMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FillMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_fillMode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_fillMode_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (FillMode) ((arg1)->fillMode);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_FillMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_cullMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  CullMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_cullMode_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_cullMode_set" "', argument " "2"" of type '" "CullMode""'");
  } 
  arg2 = static_cast< CullMode >(val2);
  if (arg1) (arg1)->cullMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_cullMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CullMode result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_cullMode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_cullMode_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (CullMode) ((arg1)->cullMode);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CullMode->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_conservativeRasterization_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  ConservativeRaster arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_conservativeRasterization_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_conservativeRasterization_set" "', argument " "2"" of type '" "ConservativeRaster""'");
  } 
  arg2 = static_cast< ConservativeRaster >(val2);
  if (arg1) (arg1)->conservativeRasterization = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_conservativeRasterization_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConservativeRaster result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_conservativeRasterization_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_conservativeRasterization_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (ConservativeRaster) ((arg1)->conservativeRasterization);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_ConservativeRaster->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_extraPrimitiveOverestimationSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_extraPrimitiveOverestimationSize_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_extraPrimitiveOverestimationSize_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->extraPrimitiveOverestimationSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_extraPrimitiveOverestimationSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_extraPrimitiveOverestimationSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_extraPrimitiveOverestimationSize_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (float) ((arg1)->extraPrimitiveOverestimationSize);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_provokingVertexFirst_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_provokingVertexFirst_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_provokingVertexFirst_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->provokingVertexFirst = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_provokingVertexFirst_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_provokingVertexFirst_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_provokingVertexFirst_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (bool) ((arg1)->provokingVertexFirst);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_depthBiasEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_depthBiasEnable_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_depthBiasEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthBiasEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_depthBiasEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_depthBiasEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_depthBiasEnable_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (bool) ((arg1)->depthBiasEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_depthBias_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_depthBias_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_depthBias_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->depthBias = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_depthBias_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_depthBias_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_depthBias_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (float) ((arg1)->depthBias);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_depthBiasClamp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_depthBiasClamp_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_depthBiasClamp_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->depthBiasClamp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_depthBiasClamp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_depthBiasClamp_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_depthBiasClamp_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (float) ((arg1)->depthBiasClamp);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_slopeScaledDepthBias_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_slopeScaledDepthBias_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_slopeScaledDepthBias_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->slopeScaledDepthBias = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_slopeScaledDepthBias_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_slopeScaledDepthBias_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_slopeScaledDepthBias_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (float) ((arg1)->slopeScaledDepthBias);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_lineWidth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_lineWidth_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_lineWidth_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->lineWidth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_lineWidth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_lineWidth_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_lineWidth_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (float) ((arg1)->lineWidth);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_lineRasterMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  LineRaster arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_lineRasterMode_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_lineRasterMode_set" "', argument " "2"" of type '" "LineRaster""'");
  } 
  arg2 = static_cast< LineRaster >(val2);
  if (arg1) (arg1)->lineRasterMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_lineRasterMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  LineRaster result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_lineRasterMode_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_lineRasterMode_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (LineRaster) ((arg1)->lineRasterMode);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_LineRaster->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_lineStippleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_lineStippleFactor_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_lineStippleFactor_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->lineStippleFactor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_lineStippleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_lineStippleFactor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_lineStippleFactor_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (uint32_t) ((arg1)->lineStippleFactor);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_lineStipplePattern_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  uint16_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_lineStipplePattern_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRasterizer_lineStipplePattern_set" "', argument " "2"" of type '" "uint16_t""'");
  } 
  arg2 = static_cast< uint16_t >(val2);
  if (arg1) (arg1)->lineStipplePattern = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_lineStipplePattern_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint16_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_lineStipplePattern_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_lineStipplePattern_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result = (uint16_t) ((arg1)->lineStipplePattern);
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_pipelineShadingRate_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  rdcpair< uint32_t,uint32_t > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_pipelineShadingRate_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_rdcpairT_unsigned_int_unsigned_int_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKRasterizer_pipelineShadingRate_set" "', argument " "2"" of type '" "rdcpair< uint32_t,uint32_t >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKRasterizer_pipelineShadingRate_set" "', argument " "2"" of type '" "rdcpair< uint32_t,uint32_t >""'");
    } else {
      rdcpair< uint32_t,uint32_t > * temp = reinterpret_cast< rdcpair< uint32_t,uint32_t > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  if (arg1) (arg1)->pipelineShadingRate = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_pipelineShadingRate_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcpair< uint32_t,uint32_t > result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_pipelineShadingRate_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_pipelineShadingRate_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result =  ((arg1)->pipelineShadingRate);
  {
    resultobj = ConvertToPy((rdcpair< uint32_t,uint32_t >&)result);
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_shadingRateCombiners_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  rdcpair< ShadingRateCombiner,ShadingRateCombiner > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_shadingRateCombiners_set" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_rdcpairT_ShadingRateCombiner_ShadingRateCombiner_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKRasterizer_shadingRateCombiners_set" "', argument " "2"" of type '" "rdcpair< ShadingRateCombiner,ShadingRateCombiner >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKRasterizer_shadingRateCombiners_set" "', argument " "2"" of type '" "rdcpair< ShadingRateCombiner,ShadingRateCombiner >""'");
    } else {
      rdcpair< ShadingRateCombiner,ShadingRateCombiner > * temp = reinterpret_cast< rdcpair< ShadingRateCombiner,ShadingRateCombiner > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  if (arg1) (arg1)->shadingRateCombiners = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRasterizer_shadingRateCombiners_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcpair< ShadingRateCombiner,ShadingRateCombiner > result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRasterizer_shadingRateCombiners_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRasterizer_shadingRateCombiners_get" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  result =  ((arg1)->shadingRateCombiners);
  {
    resultobj = ConvertToPy((rdcpair< ShadingRateCombiner,ShadingRateCombiner >&)result);
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKRasterizer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Rasterizer *arg1 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKRasterizer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Rasterizer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKRasterizer" "', argument " "1"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Rasterizer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKRasterizer) /* defines _wrap_delete_VKRasterizer_destructor_closure */

SWIGINTERN int _wrap_new_VKSampleLocations__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::SampleLocations *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::SampleLocations *)new VKPipe::SampleLocations();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__SampleLocations, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKSampleLocations__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::SampleLocations *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::SampleLocations *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__SampleLocations,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKSampleLocations" "', argument " "1"" of type '" "VKPipe::SampleLocations const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKSampleLocations" "', argument " "1"" of type '" "VKPipe::SampleLocations const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::SampleLocations * >(argp1);
  result = (VKPipe::SampleLocations *)new VKPipe::SampleLocations((VKPipe::SampleLocations const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__SampleLocations, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKSampleLocations(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKSampleLocations",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKSampleLocations__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKSampleLocations__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKSampleLocations'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::SampleLocations::SampleLocations()\n"
    "    VKPipe::SampleLocations::SampleLocations(VKPipe::SampleLocations const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKSampleLocations_gridWidth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::SampleLocations *arg1 = (VKPipe::SampleLocations *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__SampleLocations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKSampleLocations_gridWidth_set" "', argument " "1"" of type '" "VKPipe::SampleLocations *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::SampleLocations * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKSampleLocations_gridWidth_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->gridWidth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKSampleLocations_gridWidth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::SampleLocations *arg1 = (VKPipe::SampleLocations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKSampleLocations_gridWidth_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__SampleLocations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKSampleLocations_gridWidth_get" "', argument " "1"" of type '" "VKPipe::SampleLocations *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::SampleLocations * >(argp1);
  result = (uint32_t) ((arg1)->gridWidth);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKSampleLocations_gridHeight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::SampleLocations *arg1 = (VKPipe::SampleLocations *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__SampleLocations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKSampleLocations_gridHeight_set" "', argument " "1"" of type '" "VKPipe::SampleLocations *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::SampleLocations * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKSampleLocations_gridHeight_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->gridHeight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKSampleLocations_gridHeight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::SampleLocations *arg1 = (VKPipe::SampleLocations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKSampleLocations_gridHeight_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__SampleLocations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKSampleLocations_gridHeight_get" "', argument " "1"" of type '" "VKPipe::SampleLocations *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::SampleLocations * >(argp1);
  result = (uint32_t) ((arg1)->gridHeight);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKSampleLocations_customLocations_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::SampleLocations *arg1 = (VKPipe::SampleLocations *) 0 ;
  rdcarray< FloatVector > *arg2 = (rdcarray< FloatVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__SampleLocations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKSampleLocations_customLocations_set" "', argument " "1"" of type '" "VKPipe::SampleLocations *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::SampleLocations * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKSampleLocations_customLocations_set' argument 2 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKSampleLocations_customLocations_set' argument 2 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->customLocations = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKSampleLocations_customLocations_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::SampleLocations *arg1 = (VKPipe::SampleLocations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< FloatVector > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKSampleLocations_customLocations_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__SampleLocations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKSampleLocations_customLocations_get" "', argument " "1"" of type '" "VKPipe::SampleLocations *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::SampleLocations * >(argp1);
  result = (rdcarray< FloatVector > *)& ((arg1)->customLocations);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_FloatVector_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKSampleLocations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::SampleLocations *arg1 = (VKPipe::SampleLocations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKSampleLocations",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__SampleLocations, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKSampleLocations" "', argument " "1"" of type '" "VKPipe::SampleLocations *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::SampleLocations * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKSampleLocations) /* defines _wrap_delete_VKSampleLocations_destructor_closure */

SWIGINTERN int _wrap_new_VKMultiSample__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::MultiSample *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::MultiSample *)new VKPipe::MultiSample();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__MultiSample, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKMultiSample__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::MultiSample *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::MultiSample *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__MultiSample,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKMultiSample" "', argument " "1"" of type '" "VKPipe::MultiSample const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKMultiSample" "', argument " "1"" of type '" "VKPipe::MultiSample const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::MultiSample * >(argp1);
  result = (VKPipe::MultiSample *)new VKPipe::MultiSample((VKPipe::MultiSample const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__MultiSample, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKMultiSample(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKMultiSample",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKMultiSample__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKMultiSample__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKMultiSample'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::MultiSample::MultiSample()\n"
    "    VKPipe::MultiSample::MultiSample(VKPipe::MultiSample const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKMultiSample_rasterSamples_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::MultiSample *arg1 = (VKPipe::MultiSample *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__MultiSample, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKMultiSample_rasterSamples_set" "', argument " "1"" of type '" "VKPipe::MultiSample *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::MultiSample * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKMultiSample_rasterSamples_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->rasterSamples = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKMultiSample_rasterSamples_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::MultiSample *arg1 = (VKPipe::MultiSample *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKMultiSample_rasterSamples_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__MultiSample, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKMultiSample_rasterSamples_get" "', argument " "1"" of type '" "VKPipe::MultiSample *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::MultiSample * >(argp1);
  result = (uint32_t) ((arg1)->rasterSamples);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKMultiSample_sampleShadingEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::MultiSample *arg1 = (VKPipe::MultiSample *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__MultiSample, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKMultiSample_sampleShadingEnable_set" "', argument " "1"" of type '" "VKPipe::MultiSample *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::MultiSample * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKMultiSample_sampleShadingEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->sampleShadingEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKMultiSample_sampleShadingEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::MultiSample *arg1 = (VKPipe::MultiSample *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKMultiSample_sampleShadingEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__MultiSample, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKMultiSample_sampleShadingEnable_get" "', argument " "1"" of type '" "VKPipe::MultiSample *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::MultiSample * >(argp1);
  result = (bool) ((arg1)->sampleShadingEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKMultiSample_minSampleShading_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::MultiSample *arg1 = (VKPipe::MultiSample *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__MultiSample, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKMultiSample_minSampleShading_set" "', argument " "1"" of type '" "VKPipe::MultiSample *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::MultiSample * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKMultiSample_minSampleShading_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->minSampleShading = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKMultiSample_minSampleShading_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::MultiSample *arg1 = (VKPipe::MultiSample *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKMultiSample_minSampleShading_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__MultiSample, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKMultiSample_minSampleShading_get" "', argument " "1"" of type '" "VKPipe::MultiSample *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::MultiSample * >(argp1);
  result = (float) ((arg1)->minSampleShading);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKMultiSample_sampleMask_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::MultiSample *arg1 = (VKPipe::MultiSample *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__MultiSample, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKMultiSample_sampleMask_set" "', argument " "1"" of type '" "VKPipe::MultiSample *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::MultiSample * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKMultiSample_sampleMask_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->sampleMask = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKMultiSample_sampleMask_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::MultiSample *arg1 = (VKPipe::MultiSample *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKMultiSample_sampleMask_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__MultiSample, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKMultiSample_sampleMask_get" "', argument " "1"" of type '" "VKPipe::MultiSample *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::MultiSample * >(argp1);
  result = (uint32_t) ((arg1)->sampleMask);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKMultiSample_sampleLocations_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::MultiSample *arg1 = (VKPipe::MultiSample *) 0 ;
  VKPipe::SampleLocations *arg2 = (VKPipe::SampleLocations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__MultiSample, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKMultiSample_sampleLocations_set" "', argument " "1"" of type '" "VKPipe::MultiSample *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::MultiSample * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__SampleLocations, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKMultiSample_sampleLocations_set" "', argument " "2"" of type '" "VKPipe::SampleLocations *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::SampleLocations * >(argp2);
  if (arg1) (arg1)->sampleLocations = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKMultiSample_sampleLocations_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::MultiSample *arg1 = (VKPipe::MultiSample *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::SampleLocations *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKMultiSample_sampleLocations_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__MultiSample, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKMultiSample_sampleLocations_get" "', argument " "1"" of type '" "VKPipe::MultiSample *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::MultiSample * >(argp1);
  result = (VKPipe::SampleLocations *)& ((arg1)->sampleLocations);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__SampleLocations, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKMultiSample(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::MultiSample *arg1 = (VKPipe::MultiSample *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKMultiSample",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__MultiSample, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKMultiSample" "', argument " "1"" of type '" "VKPipe::MultiSample *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::MultiSample * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKMultiSample) /* defines _wrap_delete_VKMultiSample_destructor_closure */

SWIGINTERN int _wrap_new_VKColorBlendState__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::ColorBlendState *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::ColorBlendState *)new VKPipe::ColorBlendState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ColorBlendState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKColorBlendState__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::ColorBlendState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::ColorBlendState *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__ColorBlendState,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKColorBlendState" "', argument " "1"" of type '" "VKPipe::ColorBlendState const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKColorBlendState" "', argument " "1"" of type '" "VKPipe::ColorBlendState const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ColorBlendState * >(argp1);
  result = (VKPipe::ColorBlendState *)new VKPipe::ColorBlendState((VKPipe::ColorBlendState const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ColorBlendState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKColorBlendState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKColorBlendState",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKColorBlendState__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKColorBlendState__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKColorBlendState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::ColorBlendState::ColorBlendState()\n"
    "    VKPipe::ColorBlendState::ColorBlendState(VKPipe::ColorBlendState const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKColorBlendState_alphaToCoverageEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ColorBlendState *arg1 = (VKPipe::ColorBlendState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ColorBlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKColorBlendState_alphaToCoverageEnable_set" "', argument " "1"" of type '" "VKPipe::ColorBlendState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ColorBlendState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKColorBlendState_alphaToCoverageEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->alphaToCoverageEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKColorBlendState_alphaToCoverageEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ColorBlendState *arg1 = (VKPipe::ColorBlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKColorBlendState_alphaToCoverageEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ColorBlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKColorBlendState_alphaToCoverageEnable_get" "', argument " "1"" of type '" "VKPipe::ColorBlendState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ColorBlendState * >(argp1);
  result = (bool) ((arg1)->alphaToCoverageEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKColorBlendState_alphaToOneEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ColorBlendState *arg1 = (VKPipe::ColorBlendState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ColorBlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKColorBlendState_alphaToOneEnable_set" "', argument " "1"" of type '" "VKPipe::ColorBlendState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ColorBlendState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKColorBlendState_alphaToOneEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->alphaToOneEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKColorBlendState_alphaToOneEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ColorBlendState *arg1 = (VKPipe::ColorBlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKColorBlendState_alphaToOneEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ColorBlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKColorBlendState_alphaToOneEnable_get" "', argument " "1"" of type '" "VKPipe::ColorBlendState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ColorBlendState * >(argp1);
  result = (bool) ((arg1)->alphaToOneEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKColorBlendState_blends_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ColorBlendState *arg1 = (VKPipe::ColorBlendState *) 0 ;
  rdcarray< ColorBlend > *arg2 = (rdcarray< ColorBlend > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ColorBlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKColorBlendState_blends_set" "', argument " "1"" of type '" "VKPipe::ColorBlendState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ColorBlendState * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKColorBlendState_blends_set' argument 2 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKColorBlendState_blends_set' argument 2 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->blends = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKColorBlendState_blends_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ColorBlendState *arg1 = (VKPipe::ColorBlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ColorBlend > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKColorBlendState_blends_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ColorBlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKColorBlendState_blends_get" "', argument " "1"" of type '" "VKPipe::ColorBlendState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ColorBlendState * >(argp1);
  result = (rdcarray< ColorBlend > *)& ((arg1)->blends);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ColorBlend_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKColorBlendState_blendFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ColorBlendState *arg1 = (VKPipe::ColorBlendState *) 0 ;
  rdcfixedarray< float,4 > *arg2 = (rdcfixedarray< float,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[16*8] ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ColorBlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKColorBlendState_blendFactor_set" "', argument " "1"" of type '" "VKPipe::ColorBlendState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ColorBlendState * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKColorBlendState_blendFactor_set' argument 2 of type 'rdcfixedarray< float,4 >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKColorBlendState_blendFactor_set' argument 2 of type 'rdcfixedarray< float,4 >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->blendFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKColorBlendState_blendFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ColorBlendState *arg1 = (VKPipe::ColorBlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< float,4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKColorBlendState_blendFactor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ColorBlendState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKColorBlendState_blendFactor_get" "', argument " "1"" of type '" "VKPipe::ColorBlendState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ColorBlendState * >(argp1);
  result = (rdcfixedarray< float,4 > *)& ((arg1)->blendFactor);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKColorBlendState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ColorBlendState *arg1 = (VKPipe::ColorBlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKColorBlendState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ColorBlendState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKColorBlendState" "', argument " "1"" of type '" "VKPipe::ColorBlendState *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ColorBlendState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKColorBlendState) /* defines _wrap_delete_VKColorBlendState_destructor_closure */

SWIGINTERN int _wrap_new_VKDepthStencil__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::DepthStencil *)new VKPipe::DepthStencil();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__DepthStencil, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKDepthStencil__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::DepthStencil *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__DepthStencil,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKDepthStencil" "', argument " "1"" of type '" "VKPipe::DepthStencil const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKDepthStencil" "', argument " "1"" of type '" "VKPipe::DepthStencil const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  result = (VKPipe::DepthStencil *)new VKPipe::DepthStencil((VKPipe::DepthStencil const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__DepthStencil, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKDepthStencil(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKDepthStencil",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKDepthStencil__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKDepthStencil__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKDepthStencil'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::DepthStencil::DepthStencil()\n"
    "    VKPipe::DepthStencil::DepthStencil(VKPipe::DepthStencil const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_depthTestEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_depthTestEnable_set" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDepthStencil_depthTestEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthTestEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_depthTestEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDepthStencil_depthTestEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_depthTestEnable_get" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  result = (bool) ((arg1)->depthTestEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_depthWriteEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_depthWriteEnable_set" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDepthStencil_depthWriteEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthWriteEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_depthWriteEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDepthStencil_depthWriteEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_depthWriteEnable_get" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  result = (bool) ((arg1)->depthWriteEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_depthBoundsEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_depthBoundsEnable_set" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDepthStencil_depthBoundsEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthBoundsEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_depthBoundsEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDepthStencil_depthBoundsEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_depthBoundsEnable_get" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  result = (bool) ((arg1)->depthBoundsEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_depthFunction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_depthFunction_set" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDepthStencil_depthFunction_set" "', argument " "2"" of type '" "CompareFunction""'");
  } 
  arg2 = static_cast< CompareFunction >(val2);
  if (arg1) (arg1)->depthFunction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_depthFunction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompareFunction result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDepthStencil_depthFunction_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_depthFunction_get" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  result = (CompareFunction) ((arg1)->depthFunction);
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_CompareFunction->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_stencilTestEnable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_stencilTestEnable_set" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDepthStencil_stencilTestEnable_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->stencilTestEnable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_stencilTestEnable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDepthStencil_stencilTestEnable_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_stencilTestEnable_get" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  result = (bool) ((arg1)->stencilTestEnable);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_frontFace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  StencilFace *arg2 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_frontFace_set" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKDepthStencil_frontFace_set" "', argument " "2"" of type '" "StencilFace *""'"); 
  }
  arg2 = reinterpret_cast< StencilFace * >(argp2);
  if (arg1) (arg1)->frontFace = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_frontFace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StencilFace *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDepthStencil_frontFace_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_frontFace_get" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  result = (StencilFace *)& ((arg1)->frontFace);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StencilFace, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_backFace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  StencilFace *arg2 = (StencilFace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_backFace_set" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_StencilFace, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKDepthStencil_backFace_set" "', argument " "2"" of type '" "StencilFace *""'"); 
  }
  arg2 = reinterpret_cast< StencilFace * >(argp2);
  if (arg1) (arg1)->backFace = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_backFace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StencilFace *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDepthStencil_backFace_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_backFace_get" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  result = (StencilFace *)& ((arg1)->backFace);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StencilFace, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_minDepthBounds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_minDepthBounds_set" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDepthStencil_minDepthBounds_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->minDepthBounds = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_minDepthBounds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDepthStencil_minDepthBounds_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_minDepthBounds_get" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  result = (float) ((arg1)->minDepthBounds);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_maxDepthBounds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_maxDepthBounds_set" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKDepthStencil_maxDepthBounds_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->maxDepthBounds = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKDepthStencil_maxDepthBounds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKDepthStencil_maxDepthBounds_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKDepthStencil_maxDepthBounds_get" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  result = (float) ((arg1)->maxDepthBounds);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKDepthStencil(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::DepthStencil *arg1 = (VKPipe::DepthStencil *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKDepthStencil",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__DepthStencil, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKDepthStencil" "', argument " "1"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::DepthStencil * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKDepthStencil) /* defines _wrap_delete_VKDepthStencil_destructor_closure */

SWIGINTERN int _wrap_new_VKRenderPass__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::RenderPass *)new VKPipe::RenderPass();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__RenderPass, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKRenderPass__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::RenderPass *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__RenderPass,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKRenderPass" "', argument " "1"" of type '" "VKPipe::RenderPass const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKRenderPass" "', argument " "1"" of type '" "VKPipe::RenderPass const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (VKPipe::RenderPass *)new VKPipe::RenderPass((VKPipe::RenderPass const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__RenderPass, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKRenderPass(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKRenderPass",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKRenderPass__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKRenderPass__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKRenderPass'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::RenderPass::RenderPass()\n"
    "    VKPipe::RenderPass::RenderPass(VKPipe::RenderPass const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_resourceId_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKRenderPass_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_resourceId_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_dynamic_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_dynamic_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderPass_dynamic_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->dynamic = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_dynamic_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_dynamic_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_dynamic_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (bool) ((arg1)->dynamic);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_suspended_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_suspended_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderPass_suspended_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->suspended = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_suspended_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_suspended_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_suspended_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (bool) ((arg1)->suspended);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_feedbackLoop_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_feedbackLoop_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderPass_feedbackLoop_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->feedbackLoop = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_feedbackLoop_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_feedbackLoop_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_feedbackLoop_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (bool) ((arg1)->feedbackLoop);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_subpass_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_subpass_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderPass_subpass_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->subpass = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_subpass_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_subpass_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_subpass_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (uint32_t) ((arg1)->subpass);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_inputAttachments_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_inputAttachments_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKRenderPass_inputAttachments_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKRenderPass_inputAttachments_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->inputAttachments = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_inputAttachments_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_inputAttachments_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_inputAttachments_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->inputAttachments);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_colorAttachments_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_colorAttachments_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKRenderPass_colorAttachments_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKRenderPass_colorAttachments_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->colorAttachments = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_colorAttachments_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_colorAttachments_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_colorAttachments_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->colorAttachments);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_resolveAttachments_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_resolveAttachments_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKRenderPass_resolveAttachments_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKRenderPass_resolveAttachments_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->resolveAttachments = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_resolveAttachments_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_resolveAttachments_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_resolveAttachments_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->resolveAttachments);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_depthstencilAttachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_depthstencilAttachment_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderPass_depthstencilAttachment_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->depthstencilAttachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_depthstencilAttachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_depthstencilAttachment_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_depthstencilAttachment_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (int32_t) ((arg1)->depthstencilAttachment);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_depthstencilResolveAttachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_depthstencilResolveAttachment_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderPass_depthstencilResolveAttachment_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->depthstencilResolveAttachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_depthstencilResolveAttachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_depthstencilResolveAttachment_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_depthstencilResolveAttachment_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (int32_t) ((arg1)->depthstencilResolveAttachment);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_fragmentDensityAttachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_fragmentDensityAttachment_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderPass_fragmentDensityAttachment_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->fragmentDensityAttachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_fragmentDensityAttachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_fragmentDensityAttachment_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_fragmentDensityAttachment_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (int32_t) ((arg1)->fragmentDensityAttachment);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_shadingRateAttachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_shadingRateAttachment_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderPass_shadingRateAttachment_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  if (arg1) (arg1)->shadingRateAttachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_shadingRateAttachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_shadingRateAttachment_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_shadingRateAttachment_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (int32_t) ((arg1)->shadingRateAttachment);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_shadingRateTexelSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  rdcpair< uint32_t,uint32_t > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_shadingRateTexelSize_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_rdcpairT_unsigned_int_unsigned_int_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKRenderPass_shadingRateTexelSize_set" "', argument " "2"" of type '" "rdcpair< uint32_t,uint32_t >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKRenderPass_shadingRateTexelSize_set" "', argument " "2"" of type '" "rdcpair< uint32_t,uint32_t >""'");
    } else {
      rdcpair< uint32_t,uint32_t > * temp = reinterpret_cast< rdcpair< uint32_t,uint32_t > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  if (arg1) (arg1)->shadingRateTexelSize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_shadingRateTexelSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcpair< uint32_t,uint32_t > result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_shadingRateTexelSize_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_shadingRateTexelSize_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result =  ((arg1)->shadingRateTexelSize);
  {
    resultobj = ConvertToPy((rdcpair< uint32_t,uint32_t >&)result);
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_multiviews_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_multiviews_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKRenderPass_multiviews_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKRenderPass_multiviews_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->multiviews = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_multiviews_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_multiviews_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_multiviews_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->multiviews);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_fragmentDensityOffsets_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  rdcarray< Offset > *arg2 = (rdcarray< Offset > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_fragmentDensityOffsets_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKRenderPass_fragmentDensityOffsets_set' argument 2 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKRenderPass_fragmentDensityOffsets_set' argument 2 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->fragmentDensityOffsets = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_fragmentDensityOffsets_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< Offset > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_fragmentDensityOffsets_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_fragmentDensityOffsets_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (rdcarray< Offset > *)& ((arg1)->fragmentDensityOffsets);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_Offset_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_tileOnlyMSAASampleCount_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_tileOnlyMSAASampleCount_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderPass_tileOnlyMSAASampleCount_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->tileOnlyMSAASampleCount = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_tileOnlyMSAASampleCount_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_tileOnlyMSAASampleCount_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_tileOnlyMSAASampleCount_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (uint32_t) ((arg1)->tileOnlyMSAASampleCount);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_colorAttachmentLocations_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_colorAttachmentLocations_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKRenderPass_colorAttachmentLocations_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKRenderPass_colorAttachmentLocations_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->colorAttachmentLocations = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_colorAttachmentLocations_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_colorAttachmentLocations_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_colorAttachmentLocations_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->colorAttachmentLocations);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_colorAttachmentInputIndices_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  rdcarray< uint32_t > *arg2 = (rdcarray< uint32_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_colorAttachmentInputIndices_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKRenderPass_colorAttachmentInputIndices_set' argument 2 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKRenderPass_colorAttachmentInputIndices_set' argument 2 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->colorAttachmentInputIndices = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_colorAttachmentInputIndices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< uint32_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_colorAttachmentInputIndices_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_colorAttachmentInputIndices_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (rdcarray< uint32_t > *)& ((arg1)->colorAttachmentInputIndices);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_unsigned_int_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_isDepthInputAttachmentIndexImplicit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_isDepthInputAttachmentIndexImplicit_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderPass_isDepthInputAttachmentIndexImplicit_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isDepthInputAttachmentIndexImplicit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_isDepthInputAttachmentIndexImplicit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_isDepthInputAttachmentIndexImplicit_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_isDepthInputAttachmentIndexImplicit_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (bool) ((arg1)->isDepthInputAttachmentIndexImplicit);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_isStencilInputAttachmentIndexImplicit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_isStencilInputAttachmentIndexImplicit_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderPass_isStencilInputAttachmentIndexImplicit_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isStencilInputAttachmentIndexImplicit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_isStencilInputAttachmentIndexImplicit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_isStencilInputAttachmentIndexImplicit_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_isStencilInputAttachmentIndexImplicit_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (bool) ((arg1)->isStencilInputAttachmentIndexImplicit);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_depthInputAttachmentIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_depthInputAttachmentIndex_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderPass_depthInputAttachmentIndex_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->depthInputAttachmentIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_depthInputAttachmentIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_depthInputAttachmentIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_depthInputAttachmentIndex_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (uint32_t) ((arg1)->depthInputAttachmentIndex);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_stencilInputAttachmentIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_stencilInputAttachmentIndex_set" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKRenderPass_stencilInputAttachmentIndex_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->stencilInputAttachmentIndex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKRenderPass_stencilInputAttachmentIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKRenderPass_stencilInputAttachmentIndex_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKRenderPass_stencilInputAttachmentIndex_get" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  result = (uint32_t) ((arg1)->stencilInputAttachmentIndex);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKRenderPass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::RenderPass *arg1 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKRenderPass",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__RenderPass, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKRenderPass" "', argument " "1"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::RenderPass * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKRenderPass) /* defines _wrap_delete_VKRenderPass_destructor_closure */

SWIGINTERN int _wrap_new_VKFramebuffer__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::Framebuffer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::Framebuffer *)new VKPipe::Framebuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Framebuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKFramebuffer__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::Framebuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::Framebuffer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__Framebuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKFramebuffer" "', argument " "1"" of type '" "VKPipe::Framebuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKFramebuffer" "', argument " "1"" of type '" "VKPipe::Framebuffer const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Framebuffer * >(argp1);
  result = (VKPipe::Framebuffer *)new VKPipe::Framebuffer((VKPipe::Framebuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Framebuffer, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKFramebuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKFramebuffer",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKFramebuffer__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKFramebuffer__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKFramebuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::Framebuffer::Framebuffer()\n"
    "    VKPipe::Framebuffer::Framebuffer(VKPipe::Framebuffer const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKFramebuffer_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Framebuffer *arg1 = (VKPipe::Framebuffer *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Framebuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKFramebuffer_resourceId_set" "', argument " "1"" of type '" "VKPipe::Framebuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Framebuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKFramebuffer_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKFramebuffer_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Framebuffer *arg1 = (VKPipe::Framebuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKFramebuffer_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Framebuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKFramebuffer_resourceId_get" "', argument " "1"" of type '" "VKPipe::Framebuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Framebuffer * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKFramebuffer_attachments_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Framebuffer *arg1 = (VKPipe::Framebuffer *) 0 ;
  rdcarray< Descriptor > *arg2 = (rdcarray< Descriptor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Framebuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKFramebuffer_attachments_set" "', argument " "1"" of type '" "VKPipe::Framebuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Framebuffer * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKFramebuffer_attachments_set' argument 2 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKFramebuffer_attachments_set' argument 2 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->attachments = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKFramebuffer_attachments_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Framebuffer *arg1 = (VKPipe::Framebuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< Descriptor > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKFramebuffer_attachments_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Framebuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKFramebuffer_attachments_get" "', argument " "1"" of type '" "VKPipe::Framebuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Framebuffer * >(argp1);
  result = (rdcarray< Descriptor > *)& ((arg1)->attachments);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_Descriptor_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKFramebuffer_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Framebuffer *arg1 = (VKPipe::Framebuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Framebuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKFramebuffer_width_set" "', argument " "1"" of type '" "VKPipe::Framebuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Framebuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKFramebuffer_width_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKFramebuffer_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Framebuffer *arg1 = (VKPipe::Framebuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKFramebuffer_width_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Framebuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKFramebuffer_width_get" "', argument " "1"" of type '" "VKPipe::Framebuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Framebuffer * >(argp1);
  result = (uint32_t) ((arg1)->width);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKFramebuffer_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Framebuffer *arg1 = (VKPipe::Framebuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Framebuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKFramebuffer_height_set" "', argument " "1"" of type '" "VKPipe::Framebuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Framebuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKFramebuffer_height_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKFramebuffer_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Framebuffer *arg1 = (VKPipe::Framebuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKFramebuffer_height_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Framebuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKFramebuffer_height_get" "', argument " "1"" of type '" "VKPipe::Framebuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Framebuffer * >(argp1);
  result = (uint32_t) ((arg1)->height);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKFramebuffer_layers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Framebuffer *arg1 = (VKPipe::Framebuffer *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Framebuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKFramebuffer_layers_set" "', argument " "1"" of type '" "VKPipe::Framebuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Framebuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKFramebuffer_layers_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->layers = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKFramebuffer_layers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Framebuffer *arg1 = (VKPipe::Framebuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKFramebuffer_layers_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Framebuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKFramebuffer_layers_get" "', argument " "1"" of type '" "VKPipe::Framebuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Framebuffer * >(argp1);
  result = (uint32_t) ((arg1)->layers);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKFramebuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::Framebuffer *arg1 = (VKPipe::Framebuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKFramebuffer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__Framebuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKFramebuffer" "', argument " "1"" of type '" "VKPipe::Framebuffer *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::Framebuffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKFramebuffer) /* defines _wrap_delete_VKFramebuffer_destructor_closure */

SWIGINTERN int _wrap_new_VKCurrentPass__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::CurrentPass *)new VKPipe::CurrentPass();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__CurrentPass, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKCurrentPass__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::CurrentPass *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__CurrentPass,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKCurrentPass" "', argument " "1"" of type '" "VKPipe::CurrentPass const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKCurrentPass" "', argument " "1"" of type '" "VKPipe::CurrentPass const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  result = (VKPipe::CurrentPass *)new VKPipe::CurrentPass((VKPipe::CurrentPass const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__CurrentPass, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKCurrentPass(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKCurrentPass",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKCurrentPass__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKCurrentPass__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKCurrentPass'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::CurrentPass::CurrentPass()\n"
    "    VKPipe::CurrentPass::CurrentPass(VKPipe::CurrentPass const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKCurrentPass_renderpass_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = (VKPipe::CurrentPass *) 0 ;
  VKPipe::RenderPass *arg2 = (VKPipe::RenderPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKCurrentPass_renderpass_set" "', argument " "1"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKCurrentPass_renderpass_set" "', argument " "2"" of type '" "VKPipe::RenderPass *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::RenderPass * >(argp2);
  if (arg1) (arg1)->renderpass = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKCurrentPass_renderpass_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = (VKPipe::CurrentPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::RenderPass *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKCurrentPass_renderpass_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKCurrentPass_renderpass_get" "', argument " "1"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  result = (VKPipe::RenderPass *)& ((arg1)->renderpass);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__RenderPass, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKCurrentPass_framebuffer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = (VKPipe::CurrentPass *) 0 ;
  VKPipe::Framebuffer *arg2 = (VKPipe::Framebuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKCurrentPass_framebuffer_set" "', argument " "1"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__Framebuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKCurrentPass_framebuffer_set" "', argument " "2"" of type '" "VKPipe::Framebuffer *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::Framebuffer * >(argp2);
  if (arg1) (arg1)->framebuffer = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKCurrentPass_framebuffer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = (VKPipe::CurrentPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::Framebuffer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKCurrentPass_framebuffer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKCurrentPass_framebuffer_get" "', argument " "1"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  result = (VKPipe::Framebuffer *)& ((arg1)->framebuffer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Framebuffer, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKCurrentPass_renderArea_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = (VKPipe::CurrentPass *) 0 ;
  VKPipe::RenderArea *arg2 = (VKPipe::RenderArea *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKCurrentPass_renderArea_set" "', argument " "1"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__RenderArea, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKCurrentPass_renderArea_set" "', argument " "2"" of type '" "VKPipe::RenderArea *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::RenderArea * >(argp2);
  if (arg1) (arg1)->renderArea = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKCurrentPass_renderArea_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = (VKPipe::CurrentPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::RenderArea *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKCurrentPass_renderArea_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKCurrentPass_renderArea_get" "', argument " "1"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  result = (VKPipe::RenderArea *)& ((arg1)->renderArea);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__RenderArea, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKCurrentPass_colorFeedbackAllowed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = (VKPipe::CurrentPass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKCurrentPass_colorFeedbackAllowed_set" "', argument " "1"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKCurrentPass_colorFeedbackAllowed_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->colorFeedbackAllowed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKCurrentPass_colorFeedbackAllowed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = (VKPipe::CurrentPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKCurrentPass_colorFeedbackAllowed_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKCurrentPass_colorFeedbackAllowed_get" "', argument " "1"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  result = (bool) ((arg1)->colorFeedbackAllowed);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKCurrentPass_depthFeedbackAllowed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = (VKPipe::CurrentPass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKCurrentPass_depthFeedbackAllowed_set" "', argument " "1"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKCurrentPass_depthFeedbackAllowed_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->depthFeedbackAllowed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKCurrentPass_depthFeedbackAllowed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = (VKPipe::CurrentPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKCurrentPass_depthFeedbackAllowed_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKCurrentPass_depthFeedbackAllowed_get" "', argument " "1"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  result = (bool) ((arg1)->depthFeedbackAllowed);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKCurrentPass_stencilFeedbackAllowed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = (VKPipe::CurrentPass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKCurrentPass_stencilFeedbackAllowed_set" "', argument " "1"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKCurrentPass_stencilFeedbackAllowed_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->stencilFeedbackAllowed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKCurrentPass_stencilFeedbackAllowed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = (VKPipe::CurrentPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKCurrentPass_stencilFeedbackAllowed_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKCurrentPass_stencilFeedbackAllowed_get" "', argument " "1"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  result = (bool) ((arg1)->stencilFeedbackAllowed);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKCurrentPass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::CurrentPass *arg1 = (VKPipe::CurrentPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKCurrentPass",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__CurrentPass, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKCurrentPass" "', argument " "1"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::CurrentPass * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKCurrentPass) /* defines _wrap_delete_VKCurrentPass_destructor_closure */

SWIGINTERN int _wrap_new_VKImageLayout__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::ImageLayout *)new VKPipe::ImageLayout();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ImageLayout, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKImageLayout__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::ImageLayout *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__ImageLayout,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKImageLayout" "', argument " "1"" of type '" "VKPipe::ImageLayout const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKImageLayout" "', argument " "1"" of type '" "VKPipe::ImageLayout const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  result = (VKPipe::ImageLayout *)new VKPipe::ImageLayout((VKPipe::ImageLayout const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ImageLayout, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKImageLayout(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKImageLayout",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKImageLayout__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKImageLayout__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKImageLayout'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::ImageLayout::ImageLayout()\n"
    "    VKPipe::ImageLayout::ImageLayout(VKPipe::ImageLayout const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKImageLayout___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = (VKPipe::ImageLayout *) 0 ;
  VKPipe::ImageLayout *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageLayout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageLayout___eq__" "', argument " "1"" of type '" "VKPipe::ImageLayout const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__ImageLayout,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKImageLayout___eq__" "', argument " "2"" of type '" "VKPipe::ImageLayout const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKImageLayout___eq__" "', argument " "2"" of type '" "VKPipe::ImageLayout const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::ImageLayout * >(argp2);
  result = (bool)((VKPipe::ImageLayout const *)arg1)->operator ==((VKPipe::ImageLayout const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageLayout___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = (VKPipe::ImageLayout *) 0 ;
  VKPipe::ImageLayout *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageLayout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageLayout___lt__" "', argument " "1"" of type '" "VKPipe::ImageLayout const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__ImageLayout,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKImageLayout___lt__" "', argument " "2"" of type '" "VKPipe::ImageLayout const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKImageLayout___lt__" "', argument " "2"" of type '" "VKPipe::ImageLayout const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::ImageLayout * >(argp2);
  result = (bool)((VKPipe::ImageLayout const *)arg1)->operator <((VKPipe::ImageLayout const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageLayout_baseMip_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = (VKPipe::ImageLayout *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageLayout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageLayout_baseMip_set" "', argument " "1"" of type '" "VKPipe::ImageLayout *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKImageLayout_baseMip_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->baseMip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageLayout_baseMip_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = (VKPipe::ImageLayout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKImageLayout_baseMip_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageLayout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageLayout_baseMip_get" "', argument " "1"" of type '" "VKPipe::ImageLayout *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  result = (uint32_t) ((arg1)->baseMip);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageLayout_baseLayer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = (VKPipe::ImageLayout *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageLayout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageLayout_baseLayer_set" "', argument " "1"" of type '" "VKPipe::ImageLayout *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKImageLayout_baseLayer_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->baseLayer = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageLayout_baseLayer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = (VKPipe::ImageLayout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKImageLayout_baseLayer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageLayout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageLayout_baseLayer_get" "', argument " "1"" of type '" "VKPipe::ImageLayout *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  result = (uint32_t) ((arg1)->baseLayer);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageLayout_numMip_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = (VKPipe::ImageLayout *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageLayout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageLayout_numMip_set" "', argument " "1"" of type '" "VKPipe::ImageLayout *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKImageLayout_numMip_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->numMip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageLayout_numMip_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = (VKPipe::ImageLayout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKImageLayout_numMip_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageLayout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageLayout_numMip_get" "', argument " "1"" of type '" "VKPipe::ImageLayout *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  result = (uint32_t) ((arg1)->numMip);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageLayout_numLayer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = (VKPipe::ImageLayout *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageLayout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageLayout_numLayer_set" "', argument " "1"" of type '" "VKPipe::ImageLayout *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKImageLayout_numLayer_set" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  if (arg1) (arg1)->numLayer = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageLayout_numLayer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = (VKPipe::ImageLayout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKImageLayout_numLayer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageLayout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageLayout_numLayer_get" "', argument " "1"" of type '" "VKPipe::ImageLayout *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  result = (uint32_t) ((arg1)->numLayer);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageLayout_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = (VKPipe::ImageLayout *) 0 ;
  rdcstr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcstr temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageLayout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageLayout_name_set" "', argument " "1"" of type '" "VKPipe::ImageLayout *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKImageLayout_name_set' argument 2 of type 'rdcstr'"); 
    }
  }
  if (arg1) (arg1)->name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageLayout_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = (VKPipe::ImageLayout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKImageLayout_name_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageLayout, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageLayout_name_get" "', argument " "1"" of type '" "VKPipe::ImageLayout *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  result =  ((arg1)->name);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKImageLayout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageLayout *arg1 = (VKPipe::ImageLayout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKImageLayout",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageLayout, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKImageLayout" "', argument " "1"" of type '" "VKPipe::ImageLayout *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageLayout * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKImageLayout) /* defines _wrap_delete_VKImageLayout_destructor_closure */

SWIGINTERN int _wrap_new_VKImageData__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::ImageData *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::ImageData *)new VKPipe::ImageData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ImageData, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKImageData__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::ImageData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::ImageData *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__ImageData,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKImageData" "', argument " "1"" of type '" "VKPipe::ImageData const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKImageData" "', argument " "1"" of type '" "VKPipe::ImageData const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageData * >(argp1);
  result = (VKPipe::ImageData *)new VKPipe::ImageData((VKPipe::ImageData const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ImageData, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKImageData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKImageData",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKImageData__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKImageData__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKImageData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::ImageData::ImageData()\n"
    "    VKPipe::ImageData::ImageData(VKPipe::ImageData const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKImageData___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageData *arg1 = (VKPipe::ImageData *) 0 ;
  VKPipe::ImageData *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageData___eq__" "', argument " "1"" of type '" "VKPipe::ImageData const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__ImageData,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKImageData___eq__" "', argument " "2"" of type '" "VKPipe::ImageData const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKImageData___eq__" "', argument " "2"" of type '" "VKPipe::ImageData const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::ImageData * >(argp2);
  result = (bool)((VKPipe::ImageData const *)arg1)->operator ==((VKPipe::ImageData const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageData___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageData *arg1 = (VKPipe::ImageData *) 0 ;
  VKPipe::ImageData *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageData___lt__" "', argument " "1"" of type '" "VKPipe::ImageData const *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_VKPipe__ImageData,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKImageData___lt__" "', argument " "2"" of type '" "VKPipe::ImageData const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VKImageData___lt__" "', argument " "2"" of type '" "VKPipe::ImageData const &""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::ImageData * >(argp2);
  result = (bool)((VKPipe::ImageData const *)arg1)->operator <((VKPipe::ImageData const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageData_resourceId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageData *arg1 = (VKPipe::ImageData *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageData_resourceId_set" "', argument " "1"" of type '" "VKPipe::ImageData *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKImageData_resourceId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->resourceId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageData_resourceId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageData *arg1 = (VKPipe::ImageData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKImageData_resourceId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageData_resourceId_get" "', argument " "1"" of type '" "VKPipe::ImageData *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageData * >(argp1);
  result = (ResourceId *)& ((arg1)->resourceId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageData_layouts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageData *arg1 = (VKPipe::ImageData *) 0 ;
  rdcarray< VKPipe::ImageLayout > *arg2 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageData_layouts_set" "', argument " "1"" of type '" "VKPipe::ImageData *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageData * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKImageData_layouts_set' argument 2 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKImageData_layouts_set' argument 2 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->layouts = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKImageData_layouts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageData *arg1 = (VKPipe::ImageData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< VKPipe::ImageLayout > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKImageData_layouts_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKImageData_layouts_get" "', argument " "1"" of type '" "VKPipe::ImageData *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageData * >(argp1);
  result = (rdcarray< VKPipe::ImageLayout > *)& ((arg1)->layouts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_VKPipe__ImageLayout_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKImageData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ImageData *arg1 = (VKPipe::ImageData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKImageData",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ImageData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKImageData" "', argument " "1"" of type '" "VKPipe::ImageData *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ImageData * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKImageData) /* defines _wrap_delete_VKImageData_destructor_closure */

SWIGINTERN int _wrap_new_VKConditionalRendering__SWIG_0(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  VKPipe::ConditionalRendering *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (VKPipe::ConditionalRendering *)new VKPipe::ConditionalRendering();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ConditionalRendering, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKConditionalRendering__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VKPipe::ConditionalRendering *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VKPipe::ConditionalRendering *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_VKPipe__ConditionalRendering,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VKConditionalRendering" "', argument " "1"" of type '" "VKPipe::ConditionalRendering const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VKConditionalRendering" "', argument " "1"" of type '" "VKPipe::ConditionalRendering const &""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ConditionalRendering * >(argp1);
  result = (VKPipe::ConditionalRendering *)new VKPipe::ConditionalRendering((VKPipe::ConditionalRendering const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ConditionalRendering, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN int _wrap_new_VKConditionalRendering(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_VKConditionalRendering",0,1,argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VKConditionalRendering__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    return _wrap_new_VKConditionalRendering__SWIG_1(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VKConditionalRendering'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VKPipe::ConditionalRendering::ConditionalRendering()\n"
    "    VKPipe::ConditionalRendering::ConditionalRendering(VKPipe::ConditionalRendering const &)\n");
  return -1;
}


SWIGINTERN PyObject *_wrap_VKConditionalRendering_bufferId_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ConditionalRendering *arg1 = (VKPipe::ConditionalRendering *) 0 ;
  ResourceId *arg2 = (ResourceId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ConditionalRendering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKConditionalRendering_bufferId_set" "', argument " "1"" of type '" "VKPipe::ConditionalRendering *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ConditionalRendering * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_ResourceId, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKConditionalRendering_bufferId_set" "', argument " "2"" of type '" "ResourceId *""'"); 
  }
  arg2 = reinterpret_cast< ResourceId * >(argp2);
  if (arg1) (arg1)->bufferId = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKConditionalRendering_bufferId_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ConditionalRendering *arg1 = (VKPipe::ConditionalRendering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKConditionalRendering_bufferId_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ConditionalRendering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKConditionalRendering_bufferId_get" "', argument " "1"" of type '" "VKPipe::ConditionalRendering *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ConditionalRendering * >(argp1);
  result = (ResourceId *)& ((arg1)->bufferId);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResourceId, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKConditionalRendering_byteOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ConditionalRendering *arg1 = (VKPipe::ConditionalRendering *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ConditionalRendering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKConditionalRendering_byteOffset_set" "', argument " "1"" of type '" "VKPipe::ConditionalRendering *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ConditionalRendering * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKConditionalRendering_byteOffset_set" "', argument " "2"" of type '" "uint64_t""'");
  } 
  arg2 = static_cast< uint64_t >(val2);
  if (arg1) (arg1)->byteOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKConditionalRendering_byteOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ConditionalRendering *arg1 = (VKPipe::ConditionalRendering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint64_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKConditionalRendering_byteOffset_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ConditionalRendering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKConditionalRendering_byteOffset_get" "', argument " "1"" of type '" "VKPipe::ConditionalRendering *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ConditionalRendering * >(argp1);
  result = (uint64_t) ((arg1)->byteOffset);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKConditionalRendering_isInverted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ConditionalRendering *arg1 = (VKPipe::ConditionalRendering *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ConditionalRendering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKConditionalRendering_isInverted_set" "', argument " "1"" of type '" "VKPipe::ConditionalRendering *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ConditionalRendering * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKConditionalRendering_isInverted_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isInverted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKConditionalRendering_isInverted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ConditionalRendering *arg1 = (VKPipe::ConditionalRendering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKConditionalRendering_isInverted_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ConditionalRendering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKConditionalRendering_isInverted_get" "', argument " "1"" of type '" "VKPipe::ConditionalRendering *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ConditionalRendering * >(argp1);
  result = (bool) ((arg1)->isInverted);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKConditionalRendering_isPassing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ConditionalRendering *arg1 = (VKPipe::ConditionalRendering *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ConditionalRendering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKConditionalRendering_isPassing_set" "', argument " "1"" of type '" "VKPipe::ConditionalRendering *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ConditionalRendering * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VKConditionalRendering_isPassing_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isPassing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKConditionalRendering_isPassing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ConditionalRendering *arg1 = (VKPipe::ConditionalRendering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"VKConditionalRendering_isPassing_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ConditionalRendering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKConditionalRendering_isPassing_get" "', argument " "1"" of type '" "VKPipe::ConditionalRendering *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ConditionalRendering * >(argp1);
  result = (bool) ((arg1)->isPassing);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKConditionalRendering(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::ConditionalRendering *arg1 = (VKPipe::ConditionalRendering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKConditionalRendering",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__ConditionalRendering, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKConditionalRendering" "', argument " "1"" of type '" "VKPipe::ConditionalRendering *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::ConditionalRendering * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKConditionalRendering) /* defines _wrap_delete_VKConditionalRendering_destructor_closure */

SWIGINTERN PyObject *_wrap_VKState_compute_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::Pipeline *arg2 = (VKPipe::Pipeline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_compute_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_compute_set" "', argument " "2"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::Pipeline * >(argp2);
  if (arg1) (arg1)->compute = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_compute_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::Pipeline *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_compute_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_compute_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::Pipeline *)& ((arg1)->compute);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_graphics_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::Pipeline *arg2 = (VKPipe::Pipeline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_graphics_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_graphics_set" "', argument " "2"" of type '" "VKPipe::Pipeline *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::Pipeline * >(argp2);
  if (arg1) (arg1)->graphics = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_graphics_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::Pipeline *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_graphics_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_graphics_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::Pipeline *)& ((arg1)->graphics);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Pipeline, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_pushconsts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  bytebuf *arg2 = (bytebuf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bytebuf temp2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_pushconsts_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  {
    tempset(arg2, &temp2);
    
    int res = ConvertFromPy(swig_obj[0], indirect(arg2));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKState_pushconsts_set' argument 2 of type 'bytebuf'"); 
    }
  }
  if (arg1) (arg1)->pushconsts = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_pushconsts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bytebuf *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_pushconsts_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_pushconsts_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (bytebuf *)& ((arg1)->pushconsts);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_inputAssembly_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::InputAssembly *arg2 = (VKPipe::InputAssembly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_inputAssembly_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__InputAssembly, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_inputAssembly_set" "', argument " "2"" of type '" "VKPipe::InputAssembly *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::InputAssembly * >(argp2);
  if (arg1) (arg1)->inputAssembly = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_inputAssembly_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::InputAssembly *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_inputAssembly_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_inputAssembly_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::InputAssembly *)& ((arg1)->inputAssembly);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__InputAssembly, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_vertexInput_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::VertexInput *arg2 = (VKPipe::VertexInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_vertexInput_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__VertexInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_vertexInput_set" "', argument " "2"" of type '" "VKPipe::VertexInput *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::VertexInput * >(argp2);
  if (arg1) (arg1)->vertexInput = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_vertexInput_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::VertexInput *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_vertexInput_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_vertexInput_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::VertexInput *)& ((arg1)->vertexInput);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__VertexInput, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_vertexShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::Shader *arg2 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_vertexShader_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_vertexShader_set" "', argument " "2"" of type '" "VKPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::Shader * >(argp2);
  if (arg1) (arg1)->vertexShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_vertexShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_vertexShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_vertexShader_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::Shader *)& ((arg1)->vertexShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_tessControlShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::Shader *arg2 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_tessControlShader_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_tessControlShader_set" "', argument " "2"" of type '" "VKPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::Shader * >(argp2);
  if (arg1) (arg1)->tessControlShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_tessControlShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_tessControlShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_tessControlShader_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::Shader *)& ((arg1)->tessControlShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_tessEvalShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::Shader *arg2 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_tessEvalShader_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_tessEvalShader_set" "', argument " "2"" of type '" "VKPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::Shader * >(argp2);
  if (arg1) (arg1)->tessEvalShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_tessEvalShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_tessEvalShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_tessEvalShader_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::Shader *)& ((arg1)->tessEvalShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_geometryShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::Shader *arg2 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_geometryShader_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_geometryShader_set" "', argument " "2"" of type '" "VKPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::Shader * >(argp2);
  if (arg1) (arg1)->geometryShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_geometryShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_geometryShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_geometryShader_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::Shader *)& ((arg1)->geometryShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_fragmentShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::Shader *arg2 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_fragmentShader_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_fragmentShader_set" "', argument " "2"" of type '" "VKPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::Shader * >(argp2);
  if (arg1) (arg1)->fragmentShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_fragmentShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_fragmentShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_fragmentShader_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::Shader *)& ((arg1)->fragmentShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_computeShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::Shader *arg2 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_computeShader_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_computeShader_set" "', argument " "2"" of type '" "VKPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::Shader * >(argp2);
  if (arg1) (arg1)->computeShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_computeShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_computeShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_computeShader_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::Shader *)& ((arg1)->computeShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_taskShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::Shader *arg2 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_taskShader_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_taskShader_set" "', argument " "2"" of type '" "VKPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::Shader * >(argp2);
  if (arg1) (arg1)->taskShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_taskShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_taskShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_taskShader_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::Shader *)& ((arg1)->taskShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_meshShader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::Shader *arg2 = (VKPipe::Shader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_meshShader_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_meshShader_set" "', argument " "2"" of type '" "VKPipe::Shader *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::Shader * >(argp2);
  if (arg1) (arg1)->meshShader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_meshShader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::Shader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_meshShader_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_meshShader_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::Shader *)& ((arg1)->meshShader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Shader, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_tessellation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::Tessellation *arg2 = (VKPipe::Tessellation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_tessellation_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__Tessellation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_tessellation_set" "', argument " "2"" of type '" "VKPipe::Tessellation *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::Tessellation * >(argp2);
  if (arg1) (arg1)->tessellation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_tessellation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::Tessellation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_tessellation_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_tessellation_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::Tessellation *)& ((arg1)->tessellation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Tessellation, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_transformFeedback_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::TransformFeedback *arg2 = (VKPipe::TransformFeedback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_transformFeedback_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__TransformFeedback, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_transformFeedback_set" "', argument " "2"" of type '" "VKPipe::TransformFeedback *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::TransformFeedback * >(argp2);
  if (arg1) (arg1)->transformFeedback = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_transformFeedback_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::TransformFeedback *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_transformFeedback_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_transformFeedback_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::TransformFeedback *)& ((arg1)->transformFeedback);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__TransformFeedback, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_viewportScissor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::ViewState *arg2 = (VKPipe::ViewState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_viewportScissor_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__ViewState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_viewportScissor_set" "', argument " "2"" of type '" "VKPipe::ViewState *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::ViewState * >(argp2);
  if (arg1) (arg1)->viewportScissor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_viewportScissor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::ViewState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_viewportScissor_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_viewportScissor_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::ViewState *)& ((arg1)->viewportScissor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ViewState, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_rasterizer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::Rasterizer *arg2 = (VKPipe::Rasterizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_rasterizer_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_rasterizer_set" "', argument " "2"" of type '" "VKPipe::Rasterizer *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::Rasterizer * >(argp2);
  if (arg1) (arg1)->rasterizer = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_rasterizer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::Rasterizer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_rasterizer_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_rasterizer_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::Rasterizer *)& ((arg1)->rasterizer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__Rasterizer, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_multisample_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::MultiSample *arg2 = (VKPipe::MultiSample *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_multisample_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__MultiSample, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_multisample_set" "', argument " "2"" of type '" "VKPipe::MultiSample *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::MultiSample * >(argp2);
  if (arg1) (arg1)->multisample = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_multisample_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::MultiSample *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_multisample_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_multisample_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::MultiSample *)& ((arg1)->multisample);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__MultiSample, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_colorBlend_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::ColorBlendState *arg2 = (VKPipe::ColorBlendState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_colorBlend_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__ColorBlendState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_colorBlend_set" "', argument " "2"" of type '" "VKPipe::ColorBlendState *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::ColorBlendState * >(argp2);
  if (arg1) (arg1)->colorBlend = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_colorBlend_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::ColorBlendState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_colorBlend_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_colorBlend_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::ColorBlendState *)& ((arg1)->colorBlend);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ColorBlendState, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_depthStencil_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::DepthStencil *arg2 = (VKPipe::DepthStencil *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_depthStencil_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_depthStencil_set" "', argument " "2"" of type '" "VKPipe::DepthStencil *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::DepthStencil * >(argp2);
  if (arg1) (arg1)->depthStencil = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_depthStencil_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::DepthStencil *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_depthStencil_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_depthStencil_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::DepthStencil *)& ((arg1)->depthStencil);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__DepthStencil, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_currentPass_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::CurrentPass *arg2 = (VKPipe::CurrentPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_currentPass_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_currentPass_set" "', argument " "2"" of type '" "VKPipe::CurrentPass *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::CurrentPass * >(argp2);
  if (arg1) (arg1)->currentPass = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_currentPass_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::CurrentPass *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_currentPass_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_currentPass_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::CurrentPass *)& ((arg1)->currentPass);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__CurrentPass, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_images_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  rdcarray< VKPipe::ImageData > *arg2 = (rdcarray< VKPipe::ImageData > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_images_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKState_images_set' argument 2 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKState_images_set' argument 2 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->images = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_images_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< VKPipe::ImageData > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_images_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_images_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (rdcarray< VKPipe::ImageData > *)& ((arg1)->images);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_VKPipe__ImageData_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_shaderMessages_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  rdcarray< ShaderMessage > *arg2 = (rdcarray< ShaderMessage > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_shaderMessages_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(swig_obj[0], self);
    wasSelf2 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg2 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'VKState_shaderMessages_set' argument 2 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'VKState_shaderMessages_set' argument 2 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  if (arg1) (arg1)->shaderMessages = *arg2;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf2)
    tempdealloc(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_shaderMessages_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderMessage > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_shaderMessages_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_shaderMessages_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (rdcarray< ShaderMessage > *)& ((arg1)->shaderMessages);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderMessage_t, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_conditionalRendering_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  VKPipe::ConditionalRendering *arg2 = (VKPipe::ConditionalRendering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_conditionalRendering_set" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[0], &argp2,SWIGTYPE_p_VKPipe__ConditionalRendering, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VKState_conditionalRendering_set" "', argument " "2"" of type '" "VKPipe::ConditionalRendering *""'"); 
  }
  arg2 = reinterpret_cast< VKPipe::ConditionalRendering * >(argp2);
  if (arg1) (arg1)->conditionalRendering = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VKState_conditionalRendering_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  VKPipe::ConditionalRendering *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"VKState_conditionalRendering_get",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VKState_conditionalRendering_get" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  result = (VKPipe::ConditionalRendering *)& ((arg1)->conditionalRendering);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VKPipe__ConditionalRendering, 0 |  0 );
  if (SwigPyObject_Check(resultobj)) {
    SwigPyObject *sobj = (SwigPyObject *)resultobj;
    sobj->parent = self;
    Py_INCREF(self);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VKState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VKPipe::State *arg1 = (VKPipe::State *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_VKState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_VKPipe__State, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VKState" "', argument " "1"" of type '" "VKPipe::State *""'"); 
  }
  arg1 = reinterpret_cast< VKPipe::State * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_VKState) /* defines _wrap_delete_VKState_destructor_closure */

SWIGINTERN int _wrap_new_PipeState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"new_PipeState",0,0,0)) SWIG_fail;
  result = (PipeState *)new PipeState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PipeState, SWIG_BUILTIN_INIT |  0 );
  return resultobj == Py_None ? -1 : 0;
fail:
  return -1;
}


SWIGINTERN PyObject *_wrap_PipeState_IsCaptureLoaded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_IsCaptureLoaded",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_IsCaptureLoaded" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (bool)((PipeState const *)arg1)->IsCaptureLoaded();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_IsCaptureD3D11(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_IsCaptureD3D11",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_IsCaptureD3D11" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (bool)((PipeState const *)arg1)->IsCaptureD3D11();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_IsCaptureD3D12(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_IsCaptureD3D12",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_IsCaptureD3D12" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (bool)((PipeState const *)arg1)->IsCaptureD3D12();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_IsCaptureGL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_IsCaptureGL",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_IsCaptureGL" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (bool)((PipeState const *)arg1)->IsCaptureGL();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_IsCaptureVK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_IsCaptureVK",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_IsCaptureVK" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (bool)((PipeState const *)arg1)->IsCaptureVK();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_IsTessellationEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_IsTessellationEnabled",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_IsTessellationEnabled" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (bool)((PipeState const *)arg1)->IsTessellationEnabled();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_MultiviewBroadcastCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_MultiviewBroadcastCount",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_MultiviewBroadcastCount" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (uint32_t)((PipeState const *)arg1)->MultiviewBroadcastCount();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_SupportsResourceArrays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_SupportsResourceArrays",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_SupportsResourceArrays" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (bool)((PipeState const *)arg1)->SupportsResourceArrays();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_SupportsBarriers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_SupportsBarriers",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_SupportsBarriers" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (bool)((PipeState const *)arg1)->SupportsBarriers();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_HasAlignedPostVSData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  MeshDataStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_HasAlignedPostVSData" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_HasAlignedPostVSData" "', argument " "2"" of type '" "MeshDataStage""'");
  } 
  arg2 = static_cast< MeshDataStage >(val2);
  result = (bool)((PipeState const *)arg1)->HasAlignedPostVSData(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetRasterizedStream(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetRasterizedStream",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetRasterizedStream" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (int32_t)((PipeState const *)arg1)->GetRasterizedStream();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetResourceLayout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ResourceId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  rdcstr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetResourceLayout" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[0], &argp2, SWIGTYPE_p_ResourceId,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PipeState_GetResourceLayout" "', argument " "2"" of type '" "ResourceId""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PipeState_GetResourceLayout" "', argument " "2"" of type '" "ResourceId""'");
    } else {
      ResourceId * temp = reinterpret_cast< ResourceId * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = ((PipeState const *)arg1)->GetResourceLayout(arg2);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_Abbrev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  rdcstr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_Abbrev" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_Abbrev" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  result = ((PipeState const *)arg1)->Abbrev(arg2);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_OutputAbbrev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcstr result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_OutputAbbrev",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_OutputAbbrev" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->OutputAbbrev();
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetViewport(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Viewport result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetViewport" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetViewport" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  result = ((PipeState const *)arg1)->GetViewport(arg2);
  resultobj = SWIG_NewPointerObj((new Viewport(static_cast< const Viewport& >(result))), SWIGTYPE_p_Viewport, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetScissor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Scissor result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetScissor" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetScissor" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  result = ((PipeState const *)arg1)->GetScissor(arg2);
  resultobj = SWIG_NewPointerObj((new Scissor(static_cast< const Scissor& >(result))), SWIGTYPE_p_Scissor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetShaderReflection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ShaderReflection *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetShaderReflection" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetShaderReflection" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  result = (ShaderReflection *)((PipeState const *)arg1)->GetShaderReflection(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ShaderReflection, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetComputePipelineObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetComputePipelineObject",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetComputePipelineObject" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetComputePipelineObject();
  resultobj = SWIG_NewPointerObj((new ResourceId(static_cast< const ResourceId& >(result))), SWIGTYPE_p_ResourceId, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetGraphicsPipelineObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ResourceId result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetGraphicsPipelineObject",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetGraphicsPipelineObject" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetGraphicsPipelineObject();
  resultobj = SWIG_NewPointerObj((new ResourceId(static_cast< const ResourceId& >(result))), SWIGTYPE_p_ResourceId, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetShaderEntryPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  rdcstr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetShaderEntryPoint" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetShaderEntryPoint" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  result = ((PipeState const *)arg1)->GetShaderEntryPoint(arg2);
  {
    resultobj = ConvertToPy(indirect(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetShader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ResourceId result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetShader" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetShader" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  result = ((PipeState const *)arg1)->GetShader(arg2);
  resultobj = SWIG_NewPointerObj((new ResourceId(static_cast< const ResourceId& >(result))), SWIGTYPE_p_ResourceId, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetPrimitiveTopology(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Topology result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetPrimitiveTopology",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetPrimitiveTopology" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (Topology)((PipeState const *)arg1)->GetPrimitiveTopology();
  {
    SwigPyClientData *cd = NULL;
    PyObject *enum_constructor = NULL;
    PyObject *numerical = SWIG_From_int(static_cast< int >(result));
    
    cd = (SwigPyClientData*)SWIGTYPE_p_Topology->clientdata;
    if (cd->pytype->tp_dict) {
      resultobj = numerical;
    } else {
      enum_constructor = (PyObject *)cd->pytype->tp_base;
      resultobj = PyObject_CallFunctionObjArgs(enum_constructor, numerical, NULL);
      Py_DECREF(numerical);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetIBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BoundVBuffer result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetIBuffer",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetIBuffer" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetIBuffer();
  resultobj = SWIG_NewPointerObj((new BoundVBuffer(static_cast< const BoundVBuffer& >(result))), SWIGTYPE_p_BoundVBuffer, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_IsRestartEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_IsRestartEnabled",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_IsRestartEnabled" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (bool)((PipeState const *)arg1)->IsRestartEnabled();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetRestartIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetRestartIndex",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetRestartIndex" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (uint32_t)((PipeState const *)arg1)->GetRestartIndex();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetVBuffers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< BoundVBuffer > result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetVBuffers",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetVBuffers" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetVBuffers();
  resultobj = SWIG_NewPointerObj((new rdcarray< BoundVBuffer >(static_cast< const rdcarray< BoundVBuffer >& >(result))), SWIGTYPE_p_rdcarrayT_BoundVBuffer_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetVertexInputs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< VertexInputAttribute > result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetVertexInputs",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetVertexInputs" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetVertexInputs();
  resultobj = SWIG_NewPointerObj((new rdcarray< VertexInputAttribute >(static_cast< const rdcarray< VertexInputAttribute >& >(result))), SWIGTYPE_p_rdcarrayT_VertexInputAttribute_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetDescriptorAccess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< DescriptorAccess > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetDescriptorAccess",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetDescriptorAccess" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (rdcarray< DescriptorAccess > *) &((PipeState const *)arg1)->GetDescriptorAccess();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_DescriptorAccess_t, 0 |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetAllUsedDescriptors__SWIG_0(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  rdcarray< UsedDescriptor > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetAllUsedDescriptors" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetAllUsedDescriptors" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = ((PipeState const *)arg1)->GetAllUsedDescriptors(arg2);
  resultobj = SWIG_NewPointerObj((new rdcarray< UsedDescriptor >(static_cast< const rdcarray< UsedDescriptor >& >(result))), SWIGTYPE_p_rdcarrayT_UsedDescriptor_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetAllUsedDescriptors__SWIG_1(PyObject *self, int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  rdcarray< UsedDescriptor > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetAllUsedDescriptors" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetAllUsedDescriptors();
  resultobj = SWIG_NewPointerObj((new rdcarray< UsedDescriptor >(static_cast< const rdcarray< UsedDescriptor >& >(result))), SWIGTYPE_p_rdcarrayT_UsedDescriptor_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetAllUsedDescriptors(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"PipeState_GetAllUsedDescriptors",0,2,argv+1))) SWIG_fail;
  argv[0] = self;
  if (argc == 1) {
    return _wrap_PipeState_GetAllUsedDescriptors__SWIG_1(self, argc, argv);
  }
  if (argc == 2) {
    return _wrap_PipeState_GetAllUsedDescriptors__SWIG_0(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PipeState_GetAllUsedDescriptors'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PipeState::GetAllUsedDescriptors(bool) const\n"
    "    PipeState::GetAllUsedDescriptors() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PipeState_GetConstantBlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ShaderStage arg2 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  UsedDescriptor result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetConstantBlock",3,3,swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetConstantBlock" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetConstantBlock" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PipeState_GetConstantBlock" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PipeState_GetConstantBlock" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  result = ((PipeState const *)arg1)->GetConstantBlock(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj((new UsedDescriptor(static_cast< const UsedDescriptor& >(result))), SWIGTYPE_p_UsedDescriptor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetConstantBlocks__SWIG_0(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ShaderStage arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  rdcarray< UsedDescriptor > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetConstantBlocks" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetConstantBlocks" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PipeState_GetConstantBlocks" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = ((PipeState const *)arg1)->GetConstantBlocks(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new rdcarray< UsedDescriptor >(static_cast< const rdcarray< UsedDescriptor >& >(result))), SWIGTYPE_p_rdcarrayT_UsedDescriptor_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetConstantBlocks__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  rdcarray< UsedDescriptor > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetConstantBlocks" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetConstantBlocks" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  result = ((PipeState const *)arg1)->GetConstantBlocks(arg2);
  resultobj = SWIG_NewPointerObj((new rdcarray< UsedDescriptor >(static_cast< const rdcarray< UsedDescriptor >& >(result))), SWIGTYPE_p_rdcarrayT_UsedDescriptor_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetConstantBlocks(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"PipeState_GetConstantBlocks",0,3,argv+1))) SWIG_fail;
  argv[0] = self;
  if (argc == 2) {
    return _wrap_PipeState_GetConstantBlocks__SWIG_1(self, argc, argv);
  }
  if (argc == 3) {
    return _wrap_PipeState_GetConstantBlocks__SWIG_0(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PipeState_GetConstantBlocks'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PipeState::GetConstantBlocks(ShaderStage,bool) const\n"
    "    PipeState::GetConstantBlocks(ShaderStage) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PipeState_GetReadOnlyResources__SWIG_0(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ShaderStage arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  rdcarray< UsedDescriptor > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetReadOnlyResources" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetReadOnlyResources" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PipeState_GetReadOnlyResources" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = ((PipeState const *)arg1)->GetReadOnlyResources(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new rdcarray< UsedDescriptor >(static_cast< const rdcarray< UsedDescriptor >& >(result))), SWIGTYPE_p_rdcarrayT_UsedDescriptor_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetReadOnlyResources__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  rdcarray< UsedDescriptor > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetReadOnlyResources" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetReadOnlyResources" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  result = ((PipeState const *)arg1)->GetReadOnlyResources(arg2);
  resultobj = SWIG_NewPointerObj((new rdcarray< UsedDescriptor >(static_cast< const rdcarray< UsedDescriptor >& >(result))), SWIGTYPE_p_rdcarrayT_UsedDescriptor_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetReadOnlyResources(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"PipeState_GetReadOnlyResources",0,3,argv+1))) SWIG_fail;
  argv[0] = self;
  if (argc == 2) {
    return _wrap_PipeState_GetReadOnlyResources__SWIG_1(self, argc, argv);
  }
  if (argc == 3) {
    return _wrap_PipeState_GetReadOnlyResources__SWIG_0(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PipeState_GetReadOnlyResources'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PipeState::GetReadOnlyResources(ShaderStage,bool) const\n"
    "    PipeState::GetReadOnlyResources(ShaderStage) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PipeState_GetSamplers__SWIG_0(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ShaderStage arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  rdcarray< UsedDescriptor > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetSamplers" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetSamplers" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PipeState_GetSamplers" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = ((PipeState const *)arg1)->GetSamplers(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new rdcarray< UsedDescriptor >(static_cast< const rdcarray< UsedDescriptor >& >(result))), SWIGTYPE_p_rdcarrayT_UsedDescriptor_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetSamplers__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  rdcarray< UsedDescriptor > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetSamplers" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetSamplers" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  result = ((PipeState const *)arg1)->GetSamplers(arg2);
  resultobj = SWIG_NewPointerObj((new rdcarray< UsedDescriptor >(static_cast< const rdcarray< UsedDescriptor >& >(result))), SWIGTYPE_p_rdcarrayT_UsedDescriptor_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetSamplers(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"PipeState_GetSamplers",0,3,argv+1))) SWIG_fail;
  argv[0] = self;
  if (argc == 2) {
    return _wrap_PipeState_GetSamplers__SWIG_1(self, argc, argv);
  }
  if (argc == 3) {
    return _wrap_PipeState_GetSamplers__SWIG_0(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PipeState_GetSamplers'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PipeState::GetSamplers(ShaderStage,bool) const\n"
    "    PipeState::GetSamplers(ShaderStage) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PipeState_GetReadWriteResources__SWIG_0(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ShaderStage arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  rdcarray< UsedDescriptor > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetReadWriteResources" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetReadWriteResources" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PipeState_GetReadWriteResources" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = ((PipeState const *)arg1)->GetReadWriteResources(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new rdcarray< UsedDescriptor >(static_cast< const rdcarray< UsedDescriptor >& >(result))), SWIGTYPE_p_rdcarrayT_UsedDescriptor_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetReadWriteResources__SWIG_1(PyObject *self, int nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  ShaderStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  rdcarray< UsedDescriptor > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetReadWriteResources" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PipeState_GetReadWriteResources" "', argument " "2"" of type '" "ShaderStage""'");
  } 
  arg2 = static_cast< ShaderStage >(val2);
  result = ((PipeState const *)arg1)->GetReadWriteResources(arg2);
  resultobj = SWIG_NewPointerObj((new rdcarray< UsedDescriptor >(static_cast< const rdcarray< UsedDescriptor >& >(result))), SWIGTYPE_p_rdcarrayT_UsedDescriptor_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetReadWriteResources(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args,"PipeState_GetReadWriteResources",0,3,argv+1))) SWIG_fail;
  argv[0] = self;
  if (argc == 2) {
    return _wrap_PipeState_GetReadWriteResources__SWIG_1(self, argc, argv);
  }
  if (argc == 3) {
    return _wrap_PipeState_GetReadWriteResources__SWIG_0(self, argc, argv);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PipeState_GetReadWriteResources'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PipeState::GetReadWriteResources(ShaderStage,bool) const\n"
    "    PipeState::GetReadWriteResources(ShaderStage) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PipeState_GetDepthTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Descriptor result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetDepthTarget",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetDepthTarget" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetDepthTarget();
  resultobj = SWIG_NewPointerObj((new Descriptor(static_cast< const Descriptor& >(result))), SWIGTYPE_p_Descriptor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetDepthResolveTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Descriptor result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetDepthResolveTarget",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetDepthResolveTarget" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetDepthResolveTarget();
  resultobj = SWIG_NewPointerObj((new Descriptor(static_cast< const Descriptor& >(result))), SWIGTYPE_p_Descriptor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetOutputTargets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< Descriptor > result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetOutputTargets",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetOutputTargets" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetOutputTargets();
  resultobj = SWIG_NewPointerObj((new rdcarray< Descriptor >(static_cast< const rdcarray< Descriptor >& >(result))), SWIGTYPE_p_rdcarrayT_Descriptor_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetColorBlends(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ColorBlend > result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetColorBlends",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetColorBlends" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetColorBlends();
  resultobj = SWIG_NewPointerObj((new rdcarray< ColorBlend >(static_cast< const rdcarray< ColorBlend >& >(result))), SWIGTYPE_p_rdcarrayT_ColorBlend_t, SWIG_POINTER_OWN |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetBlendFactor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcfixedarray< float,4 > result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetBlendFactor",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetBlendFactor" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetBlendFactor();
  {
    resultobj = ConvertToPy(indirect(result));
  }
  {
    add_your_use_of_rdcfixedarray_to_swig_interface (&result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_IsStencilTestEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_IsStencilTestEnabled",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_IsStencilTestEnabled" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (bool)((PipeState const *)arg1)->IsStencilTestEnabled();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetStencilFaces(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< rdcpair< StencilFace,StencilFace > > result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetStencilFaces",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetStencilFaces" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetStencilFaces();
  {
    resultobj = ConvertToPy((rdcpair< StencilFace,StencilFace >&)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetDepthTestState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DepthTestState result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetDepthTestState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetDepthTestState" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetDepthTestState();
  resultobj = SWIG_NewPointerObj((new DepthTestState(static_cast< const DepthTestState& >(result))), SWIGTYPE_p_DepthTestState, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetRasterState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  RasterState result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetRasterState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetRasterState" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = ((PipeState const *)arg1)->GetRasterState();
  resultobj = SWIG_NewPointerObj((new RasterState(static_cast< const RasterState& >(result))), SWIGTYPE_p_RasterState, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_IsIndependentBlendingEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_IsIndependentBlendingEnabled",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_IsIndependentBlendingEnabled" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (bool)((PipeState const *)arg1)->IsIndependentBlendingEnabled();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PipeState_GetShaderMessages(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  rdcarray< ShaderMessage > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"PipeState_GetShaderMessages",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PipeState_GetShaderMessages" "', argument " "1"" of type '" "PipeState const *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  result = (rdcarray< ShaderMessage > *) &((PipeState const *)arg1)->GetShaderMessages();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rdcarrayT_ShaderMessage_t, 0 |  0 );
  {
    add_your_use_of_rdcarray_to_swig_interface (result); 
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PipeState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PipeState *arg1 = (PipeState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_PipeState",0,0,0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_PipeState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PipeState" "', argument " "1"" of type '" "PipeState *""'"); 
  }
  arg1 = reinterpret_cast< PipeState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_PipeState) /* defines _wrap_delete_PipeState_destructor_closure */

SWIGINTERN PyObject *_wrap_DumpObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  result = (PyObject *)RENDERDOC_DumpObject(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_rdcarray_of_int(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_int",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_int' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_int' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  rdcarray< int > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int___eq__' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int___eq__' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int___eq__' argument 2 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int___eq__' argument 2 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< int > const *)arg1)->operator ==((rdcarray< int > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  rdcarray< int > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int___ne__' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int___ne__' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int___ne__' argument 2 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int___ne__' argument 2 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< int > const *)arg1)->operator !=((rdcarray< int > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  rdcarray< int > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int___lt__' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int___lt__' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int___lt__' argument 2 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int___lt__' argument 2 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< int > const *)arg1)->operator <((rdcarray< int > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_resize_for_index' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_resize_for_index' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_int_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  size_t arg2 ;
  int *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  int temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_int_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_fill' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_fill' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_int_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_int_fill" "', argument " "3"" of type '" "int""'");
  } 
  temp3 = static_cast< int >(val3);
  arg3 = &temp3;
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(int const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_int_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_pop_back' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_pop_back' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  std::function< bool (int const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_removeIf' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_removeIf' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (int const &) >>("rdcarray_of_int_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  std::function< bool (int const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_removeOneIf' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_removeOneIf' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (int const &) >>("rdcarray_of_int_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_append' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_append' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_int_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_int_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_clear' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_clear' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_int_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_int_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_insert' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_insert' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_int_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_int_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_pop' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_pop' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_int_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_int_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_sort' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_sort' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_int_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_int_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_int_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_copy' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_copy' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_int_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_int_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_reverse' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_reverse' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_int_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_int_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_index' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_index' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_int_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_count' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_count' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_int_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_extend' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_extend' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_int_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_int_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< int > *arg1 = (rdcarray< int > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< int >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_int_remove' argument 1 of type 'rdcarray< int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_int_remove' argument 1 of type 'rdcarray< int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_int_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_int) /* defines _wrap_delete_rdcarray_of_int_destructor_closure */


PyObject *repr_rdcarray_of_int(PyObject *self)
{
  rdcarray<int> *thisptr = array_thisptr<rdcarray<int>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_int(PyObject *self, Py_ssize_t idx)
{
  rdcarray<int> *thisptr = array_thisptr<rdcarray<int>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_int(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<int> *thisptr = array_thisptr<rdcarray<int>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_int(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<int> *thisptr = array_thisptr<rdcarray<int>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_int(PyObject *self, PyObject *idx)
{
  rdcarray<int> *thisptr = array_thisptr<rdcarray<int>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_int(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<int> *thisptr = array_thisptr<rdcarray<int>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_int(PyObject *self, PyObject *vals)
{
  rdcarray<int> *thisptr = array_thisptr<rdcarray<int>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_int(PyObject *self, Py_ssize_t count)
{
  rdcarray<int> *thisptr = array_thisptr<rdcarray<int>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_int(PyObject *self, PyObject *vals)
{
  rdcarray<int> *thisptr = array_thisptr<rdcarray<int>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_int(PyObject *self, Py_ssize_t count)
{
  rdcarray<int> *thisptr = array_thisptr<rdcarray<int>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_float(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_float",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_float' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_float' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  rdcarray< float > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float___eq__' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float___eq__' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float___eq__' argument 2 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float___eq__' argument 2 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< float > const *)arg1)->operator ==((rdcarray< float > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  rdcarray< float > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float___ne__' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float___ne__' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float___ne__' argument 2 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float___ne__' argument 2 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< float > const *)arg1)->operator !=((rdcarray< float > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  rdcarray< float > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float___lt__' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float___lt__' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float___lt__' argument 2 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float___lt__' argument 2 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< float > const *)arg1)->operator <((rdcarray< float > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_resize_for_index' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_resize_for_index' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_float_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  size_t arg2 ;
  float *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  float temp3 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_float_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_fill' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_fill' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_float_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_float_fill" "', argument " "3"" of type '" "float""'");
  } 
  temp3 = static_cast< float >(val3);
  arg3 = &temp3;
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(float const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_float_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_pop_back' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_pop_back' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  std::function< bool (float const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_removeIf' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_removeIf' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (float const &) >>("rdcarray_of_float_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  std::function< bool (float const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_removeOneIf' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_removeOneIf' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (float const &) >>("rdcarray_of_float_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_append' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_append' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_float_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_float_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_clear' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_clear' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_float_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_float_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_insert' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_insert' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_float_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_float_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_pop' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_pop' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_float_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_float_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_sort' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_sort' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_float_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_float_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_float_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_copy' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_copy' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_float_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_float_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_reverse' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_reverse' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_float_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_float_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_index' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_index' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_float_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_count' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_count' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_float_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_extend' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_extend' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_float_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_float_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< float > *arg1 = (rdcarray< float > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< float >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_float_remove' argument 1 of type 'rdcarray< float >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_float_remove' argument 1 of type 'rdcarray< float >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_float_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_float) /* defines _wrap_delete_rdcarray_of_float_destructor_closure */


PyObject *repr_rdcarray_of_float(PyObject *self)
{
  rdcarray<float> *thisptr = array_thisptr<rdcarray<float>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_float(PyObject *self, Py_ssize_t idx)
{
  rdcarray<float> *thisptr = array_thisptr<rdcarray<float>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_float(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<float> *thisptr = array_thisptr<rdcarray<float>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_float(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<float> *thisptr = array_thisptr<rdcarray<float>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_float(PyObject *self, PyObject *idx)
{
  rdcarray<float> *thisptr = array_thisptr<rdcarray<float>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_float(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<float> *thisptr = array_thisptr<rdcarray<float>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_float(PyObject *self, PyObject *vals)
{
  rdcarray<float> *thisptr = array_thisptr<rdcarray<float>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_float(PyObject *self, Py_ssize_t count)
{
  rdcarray<float> *thisptr = array_thisptr<rdcarray<float>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_float(PyObject *self, PyObject *vals)
{
  rdcarray<float> *thisptr = array_thisptr<rdcarray<float>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_float(PyObject *self, Py_ssize_t count)
{
  rdcarray<float> *thisptr = array_thisptr<rdcarray<float>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_uint32_t(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_uint32_t",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_uint32_t' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_uint32_t' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  rdcarray< unsigned int > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t___eq__' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t___eq__' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< unsigned int >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t___eq__' argument 2 of type 'rdcarray< unsigned int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t___eq__' argument 2 of type 'rdcarray< unsigned int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< uint32_t > const *)arg1)->operator ==((rdcarray< unsigned int > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  rdcarray< unsigned int > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t___ne__' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t___ne__' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< unsigned int >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t___ne__' argument 2 of type 'rdcarray< unsigned int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t___ne__' argument 2 of type 'rdcarray< unsigned int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< uint32_t > const *)arg1)->operator !=((rdcarray< unsigned int > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  rdcarray< unsigned int > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t___lt__' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t___lt__' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< unsigned int >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t___lt__' argument 2 of type 'rdcarray< unsigned int >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t___lt__' argument 2 of type 'rdcarray< unsigned int >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< uint32_t > const *)arg1)->operator <((rdcarray< unsigned int > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_resize_for_index' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_resize_for_index' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_uint32_t_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  size_t arg2 ;
  unsigned int *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned int temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_uint32_t_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_fill' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_fill' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_uint32_t_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_uint32_t_fill" "', argument " "3"" of type '" "unsigned int""'");
  } 
  temp3 = static_cast< unsigned int >(val3);
  arg3 = &temp3;
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(unsigned int const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_uint32_t_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_pop_back' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_pop_back' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  std::function< bool (unsigned int const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_removeIf' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_removeIf' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (unsigned int const &) >>("rdcarray_of_uint32_t_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  std::function< bool (unsigned int const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_removeOneIf' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_removeOneIf' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (unsigned int const &) >>("rdcarray_of_uint32_t_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_append' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_append' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint32_t_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_uint32_t_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_clear' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_clear' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint32_t_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_uint32_t_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_insert' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_insert' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint32_t_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_uint32_t_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_pop' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_pop' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint32_t_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_uint32_t_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_sort' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_sort' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_uint32_t_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint32_t_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_uint32_t_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_copy' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_copy' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint32_t_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_uint32_t_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_reverse' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_reverse' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint32_t_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_uint32_t_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_index' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_index' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint32_t_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_count' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_count' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint32_t_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_extend' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_extend' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint32_t_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint32_t_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint32_t > *arg1 = (rdcarray< uint32_t > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint32_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint32_t_remove' argument 1 of type 'rdcarray< uint32_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint32_t_remove' argument 1 of type 'rdcarray< uint32_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint32_t_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_uint32_t) /* defines _wrap_delete_rdcarray_of_uint32_t_destructor_closure */


PyObject *repr_rdcarray_of_uint32_t(PyObject *self)
{
  rdcarray<uint32_t> *thisptr = array_thisptr<rdcarray<uint32_t>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_uint32_t(PyObject *self, Py_ssize_t idx)
{
  rdcarray<uint32_t> *thisptr = array_thisptr<rdcarray<uint32_t>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_uint32_t(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<uint32_t> *thisptr = array_thisptr<rdcarray<uint32_t>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_uint32_t(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<uint32_t> *thisptr = array_thisptr<rdcarray<uint32_t>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_uint32_t(PyObject *self, PyObject *idx)
{
  rdcarray<uint32_t> *thisptr = array_thisptr<rdcarray<uint32_t>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_uint32_t(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<uint32_t> *thisptr = array_thisptr<rdcarray<uint32_t>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_uint32_t(PyObject *self, PyObject *vals)
{
  rdcarray<uint32_t> *thisptr = array_thisptr<rdcarray<uint32_t>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_uint32_t(PyObject *self, Py_ssize_t count)
{
  rdcarray<uint32_t> *thisptr = array_thisptr<rdcarray<uint32_t>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_uint32_t(PyObject *self, PyObject *vals)
{
  rdcarray<uint32_t> *thisptr = array_thisptr<rdcarray<uint32_t>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_uint32_t(PyObject *self, Py_ssize_t count)
{
  rdcarray<uint32_t> *thisptr = array_thisptr<rdcarray<uint32_t>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_uint64_t(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_uint64_t",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_uint64_t' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_uint64_t' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  rdcarray< unsigned long > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t___eq__' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t___eq__' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< unsigned long >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t___eq__' argument 2 of type 'rdcarray< unsigned long >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t___eq__' argument 2 of type 'rdcarray< unsigned long >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< uint64_t > const *)arg1)->operator ==((rdcarray< unsigned long > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  rdcarray< unsigned long > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t___ne__' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t___ne__' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< unsigned long >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t___ne__' argument 2 of type 'rdcarray< unsigned long >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t___ne__' argument 2 of type 'rdcarray< unsigned long >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< uint64_t > const *)arg1)->operator !=((rdcarray< unsigned long > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  rdcarray< unsigned long > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t___lt__' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t___lt__' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< unsigned long >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t___lt__' argument 2 of type 'rdcarray< unsigned long >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t___lt__' argument 2 of type 'rdcarray< unsigned long >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< uint64_t > const *)arg1)->operator <((rdcarray< unsigned long > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_resize_for_index' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_resize_for_index' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_uint64_t_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  size_t arg2 ;
  unsigned long *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned long temp3 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_uint64_t_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_fill' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_fill' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_uint64_t_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_uint64_t_fill" "', argument " "3"" of type '" "unsigned long""'");
  } 
  temp3 = static_cast< unsigned long >(val3);
  arg3 = &temp3;
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(unsigned long const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_uint64_t_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_pop_back' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_pop_back' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  std::function< bool (unsigned long const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_removeIf' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_removeIf' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (unsigned long const &) >>("rdcarray_of_uint64_t_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  std::function< bool (unsigned long const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_removeOneIf' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_removeOneIf' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (unsigned long const &) >>("rdcarray_of_uint64_t_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_append' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_append' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint64_t_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_uint64_t_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_clear' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_clear' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint64_t_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_uint64_t_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_insert' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_insert' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint64_t_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_uint64_t_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_pop' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_pop' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint64_t_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_uint64_t_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_sort' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_sort' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_uint64_t_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint64_t_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_uint64_t_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_copy' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_copy' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint64_t_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_uint64_t_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_reverse' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_reverse' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint64_t_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_uint64_t_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_index' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_index' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint64_t_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_count' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_count' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint64_t_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_extend' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_extend' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint64_t_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_uint64_t_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< uint64_t > *arg1 = (rdcarray< uint64_t > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< uint64_t >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_uint64_t_remove' argument 1 of type 'rdcarray< uint64_t >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_uint64_t_remove' argument 1 of type 'rdcarray< uint64_t >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_uint64_t_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_uint64_t) /* defines _wrap_delete_rdcarray_of_uint64_t_destructor_closure */


PyObject *repr_rdcarray_of_uint64_t(PyObject *self)
{
  rdcarray<uint64_t> *thisptr = array_thisptr<rdcarray<uint64_t>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_uint64_t(PyObject *self, Py_ssize_t idx)
{
  rdcarray<uint64_t> *thisptr = array_thisptr<rdcarray<uint64_t>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_uint64_t(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<uint64_t> *thisptr = array_thisptr<rdcarray<uint64_t>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_uint64_t(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<uint64_t> *thisptr = array_thisptr<rdcarray<uint64_t>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_uint64_t(PyObject *self, PyObject *idx)
{
  rdcarray<uint64_t> *thisptr = array_thisptr<rdcarray<uint64_t>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_uint64_t(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<uint64_t> *thisptr = array_thisptr<rdcarray<uint64_t>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_uint64_t(PyObject *self, PyObject *vals)
{
  rdcarray<uint64_t> *thisptr = array_thisptr<rdcarray<uint64_t>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_uint64_t(PyObject *self, Py_ssize_t count)
{
  rdcarray<uint64_t> *thisptr = array_thisptr<rdcarray<uint64_t>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_uint64_t(PyObject *self, PyObject *vals)
{
  rdcarray<uint64_t> *thisptr = array_thisptr<rdcarray<uint64_t>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_uint64_t(PyObject *self, Py_ssize_t count)
{
  rdcarray<uint64_t> *thisptr = array_thisptr<rdcarray<uint64_t>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_rdcstr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_rdcstr",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_rdcstr' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_rdcstr' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  rdcarray< rdcstr > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr___eq__' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr___eq__' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr___eq__' argument 2 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr___eq__' argument 2 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< rdcstr > const *)arg1)->operator ==((rdcarray< rdcstr > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  rdcarray< rdcstr > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr___ne__' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr___ne__' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr___ne__' argument 2 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr___ne__' argument 2 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< rdcstr > const *)arg1)->operator !=((rdcarray< rdcstr > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  rdcarray< rdcstr > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr___lt__' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr___lt__' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr___lt__' argument 2 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr___lt__' argument 2 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< rdcstr > const *)arg1)->operator <((rdcarray< rdcstr > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_resize_for_index' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_resize_for_index' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_rdcstr_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  size_t arg2 ;
  rdcstr *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  rdcstr temp3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_rdcstr_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_fill' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_fill' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_rdcstr_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    tempset(arg3, &temp3);
    
    int res = ConvertFromPy(swig_obj[1], indirect(arg3));
    if(!SWIG_IsOK(res))
    {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_fill' argument 3 of type 'rdcstr'"); 
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(rdcstr const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_rdcstr_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_pop_back' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_pop_back' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  std::function< bool (rdcstr const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_removeIf' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_removeIf' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (rdcstr const &) >>("rdcarray_of_rdcstr_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  std::function< bool (rdcstr const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_removeOneIf' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_removeOneIf' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (rdcstr const &) >>("rdcarray_of_rdcstr_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_append' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_append' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_rdcstr_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_rdcstr_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_clear' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_clear' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_rdcstr_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_rdcstr_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_insert' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_insert' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_rdcstr_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_rdcstr_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_pop' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_pop' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_rdcstr_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_rdcstr_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_sort' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_sort' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_rdcstr_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_rdcstr_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_rdcstr_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_copy' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_copy' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_rdcstr_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_rdcstr_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_reverse' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_reverse' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_rdcstr_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_rdcstr_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_index' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_index' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_rdcstr_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_count' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_count' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_rdcstr_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_extend' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_extend' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_rdcstr_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_rdcstr_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< rdcstr > *arg1 = (rdcarray< rdcstr > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< rdcstr >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_rdcstr_remove' argument 1 of type 'rdcarray< rdcstr >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_rdcstr_remove' argument 1 of type 'rdcarray< rdcstr >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_rdcstr_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_rdcstr) /* defines _wrap_delete_rdcarray_of_rdcstr_destructor_closure */


PyObject *repr_rdcarray_of_rdcstr(PyObject *self)
{
  rdcarray<rdcstr> *thisptr = array_thisptr<rdcarray<rdcstr>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_rdcstr(PyObject *self, Py_ssize_t idx)
{
  rdcarray<rdcstr> *thisptr = array_thisptr<rdcarray<rdcstr>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_rdcstr(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<rdcstr> *thisptr = array_thisptr<rdcarray<rdcstr>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_rdcstr(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<rdcstr> *thisptr = array_thisptr<rdcarray<rdcstr>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_rdcstr(PyObject *self, PyObject *idx)
{
  rdcarray<rdcstr> *thisptr = array_thisptr<rdcarray<rdcstr>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_rdcstr(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<rdcstr> *thisptr = array_thisptr<rdcarray<rdcstr>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_rdcstr(PyObject *self, PyObject *vals)
{
  rdcarray<rdcstr> *thisptr = array_thisptr<rdcarray<rdcstr>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_rdcstr(PyObject *self, Py_ssize_t count)
{
  rdcarray<rdcstr> *thisptr = array_thisptr<rdcarray<rdcstr>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_rdcstr(PyObject *self, PyObject *vals)
{
  rdcarray<rdcstr> *thisptr = array_thisptr<rdcarray<rdcstr>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_rdcstr(PyObject *self, Py_ssize_t count)
{
  rdcarray<rdcstr> *thisptr = array_thisptr<rdcarray<rdcstr>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_WindowingSystem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_WindowingSystem",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_WindowingSystem' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_WindowingSystem' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  rdcarray< WindowingSystem > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem___eq__' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem___eq__' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem___eq__' argument 2 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem___eq__' argument 2 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< WindowingSystem > const *)arg1)->operator ==((rdcarray< WindowingSystem > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  rdcarray< WindowingSystem > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem___ne__' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem___ne__' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem___ne__' argument 2 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem___ne__' argument 2 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< WindowingSystem > const *)arg1)->operator !=((rdcarray< WindowingSystem > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  rdcarray< WindowingSystem > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem___lt__' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem___lt__' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem___lt__' argument 2 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem___lt__' argument 2 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< WindowingSystem > const *)arg1)->operator <((rdcarray< WindowingSystem > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_resize_for_index' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_resize_for_index' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_WindowingSystem_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  size_t arg2 ;
  WindowingSystem *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 ;
  WindowingSystem temp3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_WindowingSystem_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_fill' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_fill' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_WindowingSystem_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int (swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_WindowingSystem_fill" "', argument " "3"" of type '" "WindowingSystem const &""'");
  } else {
    temp3 = static_cast< WindowingSystem >(val3);
    arg3 = &temp3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(WindowingSystem const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_WindowingSystem_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_pop_back' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_pop_back' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  std::function< bool (WindowingSystem const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_removeIf' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_removeIf' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (WindowingSystem const &) >>("rdcarray_of_WindowingSystem_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  std::function< bool (WindowingSystem const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_removeOneIf' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_removeOneIf' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (WindowingSystem const &) >>("rdcarray_of_WindowingSystem_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_append' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_append' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_WindowingSystem_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_WindowingSystem_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_clear' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_clear' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_WindowingSystem_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_WindowingSystem_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_insert' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_insert' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_WindowingSystem_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_WindowingSystem_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_pop' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_pop' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_WindowingSystem_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_WindowingSystem_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_sort' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_sort' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_WindowingSystem_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_WindowingSystem_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_WindowingSystem_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_copy' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_copy' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_WindowingSystem_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_WindowingSystem_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_reverse' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_reverse' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_WindowingSystem_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_WindowingSystem_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_index' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_index' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_WindowingSystem_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_count' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_count' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_WindowingSystem_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_extend' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_extend' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_WindowingSystem_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_WindowingSystem_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< WindowingSystem > *arg1 = (rdcarray< WindowingSystem > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< WindowingSystem >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_WindowingSystem_remove' argument 1 of type 'rdcarray< WindowingSystem >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_WindowingSystem_remove' argument 1 of type 'rdcarray< WindowingSystem >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_WindowingSystem_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_WindowingSystem) /* defines _wrap_delete_rdcarray_of_WindowingSystem_destructor_closure */


PyObject *repr_rdcarray_of_WindowingSystem(PyObject *self)
{
  rdcarray<WindowingSystem> *thisptr = array_thisptr<rdcarray<WindowingSystem>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_WindowingSystem(PyObject *self, Py_ssize_t idx)
{
  rdcarray<WindowingSystem> *thisptr = array_thisptr<rdcarray<WindowingSystem>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_WindowingSystem(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<WindowingSystem> *thisptr = array_thisptr<rdcarray<WindowingSystem>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_WindowingSystem(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<WindowingSystem> *thisptr = array_thisptr<rdcarray<WindowingSystem>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_WindowingSystem(PyObject *self, PyObject *idx)
{
  rdcarray<WindowingSystem> *thisptr = array_thisptr<rdcarray<WindowingSystem>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_WindowingSystem(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<WindowingSystem> *thisptr = array_thisptr<rdcarray<WindowingSystem>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_WindowingSystem(PyObject *self, PyObject *vals)
{
  rdcarray<WindowingSystem> *thisptr = array_thisptr<rdcarray<WindowingSystem>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_WindowingSystem(PyObject *self, Py_ssize_t count)
{
  rdcarray<WindowingSystem> *thisptr = array_thisptr<rdcarray<WindowingSystem>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_WindowingSystem(PyObject *self, PyObject *vals)
{
  rdcarray<WindowingSystem> *thisptr = array_thisptr<rdcarray<WindowingSystem>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_WindowingSystem(PyObject *self, Py_ssize_t count)
{
  rdcarray<WindowingSystem> *thisptr = array_thisptr<rdcarray<WindowingSystem>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ActionDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ActionDescription",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ActionDescription' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ActionDescription' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  rdcarray< ActionDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription___eq__' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription___eq__' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription___eq__' argument 2 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription___eq__' argument 2 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ActionDescription > const *)arg1)->operator ==((rdcarray< ActionDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  rdcarray< ActionDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription___ne__' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription___ne__' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription___ne__' argument 2 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription___ne__' argument 2 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ActionDescription > const *)arg1)->operator !=((rdcarray< ActionDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  rdcarray< ActionDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription___lt__' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription___lt__' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription___lt__' argument 2 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription___lt__' argument 2 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ActionDescription > const *)arg1)->operator <((rdcarray< ActionDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_resize_for_index' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_resize_for_index' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ActionDescription_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  size_t arg2 ;
  ActionDescription *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ActionDescription_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_fill' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_fill' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ActionDescription_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ActionDescription,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ActionDescription_fill" "', argument " "3"" of type '" "ActionDescription const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ActionDescription_fill" "', argument " "3"" of type '" "ActionDescription const &""'"); 
  }
  arg3 = reinterpret_cast< ActionDescription * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ActionDescription const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ActionDescription_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_pop_back' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_pop_back' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  SwigValueWrapper< std::function< bool (ActionDescription const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_removeIf' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_removeIf' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ActionDescription const &) >>("rdcarray_of_ActionDescription_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  SwigValueWrapper< std::function< bool (ActionDescription const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_removeOneIf' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_removeOneIf' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ActionDescription const &) >>("rdcarray_of_ActionDescription_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_append' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_append' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ActionDescription_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ActionDescription_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_clear' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_clear' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ActionDescription_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ActionDescription_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_insert' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_insert' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ActionDescription_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ActionDescription_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_pop' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_pop' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ActionDescription_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ActionDescription_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_sort' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_sort' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ActionDescription_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ActionDescription_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ActionDescription_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_copy' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_copy' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ActionDescription_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ActionDescription_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_reverse' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_reverse' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ActionDescription_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ActionDescription_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_index' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_index' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ActionDescription_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_count' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_count' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ActionDescription_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_extend' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_extend' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ActionDescription_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ActionDescription_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ActionDescription > *arg1 = (rdcarray< ActionDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ActionDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ActionDescription_remove' argument 1 of type 'rdcarray< ActionDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ActionDescription_remove' argument 1 of type 'rdcarray< ActionDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ActionDescription_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ActionDescription) /* defines _wrap_delete_rdcarray_of_ActionDescription_destructor_closure */


PyObject *repr_rdcarray_of_ActionDescription(PyObject *self)
{
  rdcarray<ActionDescription> *thisptr = array_thisptr<rdcarray<ActionDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ActionDescription(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ActionDescription> *thisptr = array_thisptr<rdcarray<ActionDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ActionDescription(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ActionDescription> *thisptr = array_thisptr<rdcarray<ActionDescription>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ActionDescription(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ActionDescription> *thisptr = array_thisptr<rdcarray<ActionDescription>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ActionDescription(PyObject *self, PyObject *idx)
{
  rdcarray<ActionDescription> *thisptr = array_thisptr<rdcarray<ActionDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ActionDescription(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ActionDescription> *thisptr = array_thisptr<rdcarray<ActionDescription>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ActionDescription(PyObject *self, PyObject *vals)
{
  rdcarray<ActionDescription> *thisptr = array_thisptr<rdcarray<ActionDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ActionDescription(PyObject *self, Py_ssize_t count)
{
  rdcarray<ActionDescription> *thisptr = array_thisptr<rdcarray<ActionDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ActionDescription(PyObject *self, PyObject *vals)
{
  rdcarray<ActionDescription> *thisptr = array_thisptr<rdcarray<ActionDescription>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ActionDescription(PyObject *self, Py_ssize_t count)
{
  rdcarray<ActionDescription> *thisptr = array_thisptr<rdcarray<ActionDescription>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_GPUCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_GPUCounter",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_GPUCounter' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_GPUCounter' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  rdcarray< GPUCounter > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter___eq__' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter___eq__' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter___eq__' argument 2 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter___eq__' argument 2 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GPUCounter > const *)arg1)->operator ==((rdcarray< GPUCounter > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  rdcarray< GPUCounter > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter___ne__' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter___ne__' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter___ne__' argument 2 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter___ne__' argument 2 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GPUCounter > const *)arg1)->operator !=((rdcarray< GPUCounter > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  rdcarray< GPUCounter > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter___lt__' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter___lt__' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter___lt__' argument 2 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter___lt__' argument 2 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GPUCounter > const *)arg1)->operator <((rdcarray< GPUCounter > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_resize_for_index' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_resize_for_index' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_GPUCounter_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  size_t arg2 ;
  GPUCounter *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 ;
  GPUCounter temp3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GPUCounter_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_fill' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_fill' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_GPUCounter_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int (swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_GPUCounter_fill" "', argument " "3"" of type '" "GPUCounter const &""'");
  } else {
    temp3 = static_cast< GPUCounter >(val3);
    arg3 = &temp3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(GPUCounter const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GPUCounter_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_pop_back' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_pop_back' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  std::function< bool (GPUCounter const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_removeIf' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_removeIf' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (GPUCounter const &) >>("rdcarray_of_GPUCounter_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  std::function< bool (GPUCounter const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_removeOneIf' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_removeOneIf' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (GPUCounter const &) >>("rdcarray_of_GPUCounter_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_append' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_append' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUCounter_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GPUCounter_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_clear' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_clear' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUCounter_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GPUCounter_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_insert' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_insert' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUCounter_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_GPUCounter_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_pop' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_pop' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUCounter_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_GPUCounter_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_sort' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_sort' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_GPUCounter_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUCounter_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GPUCounter_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_copy' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_copy' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUCounter_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GPUCounter_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_reverse' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_reverse' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUCounter_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_GPUCounter_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_index' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_index' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUCounter_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_count' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_count' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUCounter_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_extend' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_extend' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUCounter_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUCounter_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUCounter > *arg1 = (rdcarray< GPUCounter > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUCounter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUCounter_remove' argument 1 of type 'rdcarray< GPUCounter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUCounter_remove' argument 1 of type 'rdcarray< GPUCounter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUCounter_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_GPUCounter) /* defines _wrap_delete_rdcarray_of_GPUCounter_destructor_closure */


PyObject *repr_rdcarray_of_GPUCounter(PyObject *self)
{
  rdcarray<GPUCounter> *thisptr = array_thisptr<rdcarray<GPUCounter>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_GPUCounter(PyObject *self, Py_ssize_t idx)
{
  rdcarray<GPUCounter> *thisptr = array_thisptr<rdcarray<GPUCounter>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_GPUCounter(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<GPUCounter> *thisptr = array_thisptr<rdcarray<GPUCounter>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_GPUCounter(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<GPUCounter> *thisptr = array_thisptr<rdcarray<GPUCounter>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_GPUCounter(PyObject *self, PyObject *idx)
{
  rdcarray<GPUCounter> *thisptr = array_thisptr<rdcarray<GPUCounter>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_GPUCounter(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<GPUCounter> *thisptr = array_thisptr<rdcarray<GPUCounter>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_GPUCounter(PyObject *self, PyObject *vals)
{
  rdcarray<GPUCounter> *thisptr = array_thisptr<rdcarray<GPUCounter>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_GPUCounter(PyObject *self, Py_ssize_t count)
{
  rdcarray<GPUCounter> *thisptr = array_thisptr<rdcarray<GPUCounter>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_GPUCounter(PyObject *self, PyObject *vals)
{
  rdcarray<GPUCounter> *thisptr = array_thisptr<rdcarray<GPUCounter>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_GPUCounter(PyObject *self, Py_ssize_t count)
{
  rdcarray<GPUCounter> *thisptr = array_thisptr<rdcarray<GPUCounter>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_CounterResult(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_CounterResult",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_CounterResult' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_CounterResult' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  rdcarray< CounterResult > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult___eq__' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult___eq__' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult___eq__' argument 2 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult___eq__' argument 2 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< CounterResult > const *)arg1)->operator ==((rdcarray< CounterResult > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  rdcarray< CounterResult > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult___ne__' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult___ne__' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult___ne__' argument 2 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult___ne__' argument 2 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< CounterResult > const *)arg1)->operator !=((rdcarray< CounterResult > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  rdcarray< CounterResult > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult___lt__' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult___lt__' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult___lt__' argument 2 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult___lt__' argument 2 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< CounterResult > const *)arg1)->operator <((rdcarray< CounterResult > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_resize_for_index' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_resize_for_index' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_CounterResult_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  size_t arg2 ;
  CounterResult *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_CounterResult_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_fill' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_fill' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_CounterResult_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_CounterResult,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_CounterResult_fill" "', argument " "3"" of type '" "CounterResult const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_CounterResult_fill" "', argument " "3"" of type '" "CounterResult const &""'"); 
  }
  arg3 = reinterpret_cast< CounterResult * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(CounterResult const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_CounterResult_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_pop_back' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_pop_back' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  SwigValueWrapper< std::function< bool (CounterResult const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_removeIf' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_removeIf' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (CounterResult const &) >>("rdcarray_of_CounterResult_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  SwigValueWrapper< std::function< bool (CounterResult const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_removeOneIf' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_removeOneIf' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (CounterResult const &) >>("rdcarray_of_CounterResult_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_append' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_append' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CounterResult_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_CounterResult_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_clear' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_clear' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CounterResult_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_CounterResult_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_insert' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_insert' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CounterResult_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_CounterResult_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_pop' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_pop' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CounterResult_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_CounterResult_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_sort' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_sort' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_CounterResult_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CounterResult_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_CounterResult_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_copy' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_copy' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CounterResult_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_CounterResult_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_reverse' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_reverse' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CounterResult_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_CounterResult_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_index' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_index' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CounterResult_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_count' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_count' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CounterResult_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_extend' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_extend' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CounterResult_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CounterResult_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CounterResult > *arg1 = (rdcarray< CounterResult > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CounterResult >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CounterResult_remove' argument 1 of type 'rdcarray< CounterResult >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CounterResult_remove' argument 1 of type 'rdcarray< CounterResult >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CounterResult_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_CounterResult) /* defines _wrap_delete_rdcarray_of_CounterResult_destructor_closure */


PyObject *repr_rdcarray_of_CounterResult(PyObject *self)
{
  rdcarray<CounterResult> *thisptr = array_thisptr<rdcarray<CounterResult>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_CounterResult(PyObject *self, Py_ssize_t idx)
{
  rdcarray<CounterResult> *thisptr = array_thisptr<rdcarray<CounterResult>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_CounterResult(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<CounterResult> *thisptr = array_thisptr<rdcarray<CounterResult>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_CounterResult(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<CounterResult> *thisptr = array_thisptr<rdcarray<CounterResult>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_CounterResult(PyObject *self, PyObject *idx)
{
  rdcarray<CounterResult> *thisptr = array_thisptr<rdcarray<CounterResult>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_CounterResult(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<CounterResult> *thisptr = array_thisptr<rdcarray<CounterResult>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_CounterResult(PyObject *self, PyObject *vals)
{
  rdcarray<CounterResult> *thisptr = array_thisptr<rdcarray<CounterResult>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_CounterResult(PyObject *self, Py_ssize_t count)
{
  rdcarray<CounterResult> *thisptr = array_thisptr<rdcarray<CounterResult>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_CounterResult(PyObject *self, PyObject *vals)
{
  rdcarray<CounterResult> *thisptr = array_thisptr<rdcarray<CounterResult>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_CounterResult(PyObject *self, Py_ssize_t count)
{
  rdcarray<CounterResult> *thisptr = array_thisptr<rdcarray<CounterResult>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_APIEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_APIEvent",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_APIEvent' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_APIEvent' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  rdcarray< APIEvent > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent___eq__' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent___eq__' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent___eq__' argument 2 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent___eq__' argument 2 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< APIEvent > const *)arg1)->operator ==((rdcarray< APIEvent > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  rdcarray< APIEvent > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent___ne__' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent___ne__' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent___ne__' argument 2 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent___ne__' argument 2 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< APIEvent > const *)arg1)->operator !=((rdcarray< APIEvent > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  rdcarray< APIEvent > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent___lt__' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent___lt__' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent___lt__' argument 2 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent___lt__' argument 2 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< APIEvent > const *)arg1)->operator <((rdcarray< APIEvent > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_resize_for_index' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_resize_for_index' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_APIEvent_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  size_t arg2 ;
  APIEvent *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_APIEvent_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_fill' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_fill' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_APIEvent_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_APIEvent,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_APIEvent_fill" "', argument " "3"" of type '" "APIEvent const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_APIEvent_fill" "', argument " "3"" of type '" "APIEvent const &""'"); 
  }
  arg3 = reinterpret_cast< APIEvent * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(APIEvent const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_APIEvent_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_pop_back' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_pop_back' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  SwigValueWrapper< std::function< bool (APIEvent const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_removeIf' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_removeIf' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (APIEvent const &) >>("rdcarray_of_APIEvent_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  SwigValueWrapper< std::function< bool (APIEvent const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_removeOneIf' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_removeOneIf' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (APIEvent const &) >>("rdcarray_of_APIEvent_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_append' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_append' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_APIEvent_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_APIEvent_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_clear' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_clear' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_APIEvent_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_APIEvent_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_insert' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_insert' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_APIEvent_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_APIEvent_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_pop' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_pop' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_APIEvent_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_APIEvent_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_sort' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_sort' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_APIEvent_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_APIEvent_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_APIEvent_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_copy' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_copy' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_APIEvent_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_APIEvent_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_reverse' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_reverse' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_APIEvent_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_APIEvent_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_index' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_index' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_APIEvent_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_count' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_count' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_APIEvent_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_extend' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_extend' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_APIEvent_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_APIEvent_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< APIEvent > *arg1 = (rdcarray< APIEvent > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< APIEvent >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_APIEvent_remove' argument 1 of type 'rdcarray< APIEvent >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_APIEvent_remove' argument 1 of type 'rdcarray< APIEvent >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_APIEvent_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_APIEvent) /* defines _wrap_delete_rdcarray_of_APIEvent_destructor_closure */


PyObject *repr_rdcarray_of_APIEvent(PyObject *self)
{
  rdcarray<APIEvent> *thisptr = array_thisptr<rdcarray<APIEvent>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_APIEvent(PyObject *self, Py_ssize_t idx)
{
  rdcarray<APIEvent> *thisptr = array_thisptr<rdcarray<APIEvent>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_APIEvent(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<APIEvent> *thisptr = array_thisptr<rdcarray<APIEvent>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_APIEvent(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<APIEvent> *thisptr = array_thisptr<rdcarray<APIEvent>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_APIEvent(PyObject *self, PyObject *idx)
{
  rdcarray<APIEvent> *thisptr = array_thisptr<rdcarray<APIEvent>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_APIEvent(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<APIEvent> *thisptr = array_thisptr<rdcarray<APIEvent>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_APIEvent(PyObject *self, PyObject *vals)
{
  rdcarray<APIEvent> *thisptr = array_thisptr<rdcarray<APIEvent>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_APIEvent(PyObject *self, Py_ssize_t count)
{
  rdcarray<APIEvent> *thisptr = array_thisptr<rdcarray<APIEvent>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_APIEvent(PyObject *self, PyObject *vals)
{
  rdcarray<APIEvent> *thisptr = array_thisptr<rdcarray<APIEvent>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_APIEvent(PyObject *self, Py_ssize_t count)
{
  rdcarray<APIEvent> *thisptr = array_thisptr<rdcarray<APIEvent>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_DescriptorStoreDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_DescriptorStoreDescription",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_DescriptorStoreDescription' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_DescriptorStoreDescription' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  rdcarray< DescriptorStoreDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription___eq__' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription___eq__' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription___eq__' argument 2 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription___eq__' argument 2 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DescriptorStoreDescription > const *)arg1)->operator ==((rdcarray< DescriptorStoreDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  rdcarray< DescriptorStoreDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription___ne__' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription___ne__' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription___ne__' argument 2 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription___ne__' argument 2 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DescriptorStoreDescription > const *)arg1)->operator !=((rdcarray< DescriptorStoreDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  rdcarray< DescriptorStoreDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription___lt__' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription___lt__' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription___lt__' argument 2 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription___lt__' argument 2 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DescriptorStoreDescription > const *)arg1)->operator <((rdcarray< DescriptorStoreDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_resize_for_index' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_resize_for_index' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_DescriptorStoreDescription_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  size_t arg2 ;
  DescriptorStoreDescription *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorStoreDescription_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_fill' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_fill' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_DescriptorStoreDescription_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_DescriptorStoreDescription,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_DescriptorStoreDescription_fill" "', argument " "3"" of type '" "DescriptorStoreDescription const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_DescriptorStoreDescription_fill" "', argument " "3"" of type '" "DescriptorStoreDescription const &""'"); 
  }
  arg3 = reinterpret_cast< DescriptorStoreDescription * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(DescriptorStoreDescription const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorStoreDescription_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_pop_back' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_pop_back' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  SwigValueWrapper< std::function< bool (DescriptorStoreDescription const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_removeIf' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_removeIf' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (DescriptorStoreDescription const &) >>("rdcarray_of_DescriptorStoreDescription_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  SwigValueWrapper< std::function< bool (DescriptorStoreDescription const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_removeOneIf' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_removeOneIf' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (DescriptorStoreDescription const &) >>("rdcarray_of_DescriptorStoreDescription_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_append' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_append' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorStoreDescription_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorStoreDescription_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_clear' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_clear' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorStoreDescription_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorStoreDescription_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_insert' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_insert' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorStoreDescription_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_DescriptorStoreDescription_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_pop' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_pop' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorStoreDescription_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_DescriptorStoreDescription_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_sort' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_sort' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_DescriptorStoreDescription_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorStoreDescription_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorStoreDescription_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_copy' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_copy' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorStoreDescription_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorStoreDescription_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_reverse' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_reverse' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorStoreDescription_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_DescriptorStoreDescription_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_index' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_index' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorStoreDescription_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_count' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_count' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorStoreDescription_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_extend' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_extend' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorStoreDescription_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorStoreDescription_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorStoreDescription > *arg1 = (rdcarray< DescriptorStoreDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorStoreDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorStoreDescription_remove' argument 1 of type 'rdcarray< DescriptorStoreDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorStoreDescription_remove' argument 1 of type 'rdcarray< DescriptorStoreDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorStoreDescription_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_DescriptorStoreDescription) /* defines _wrap_delete_rdcarray_of_DescriptorStoreDescription_destructor_closure */


PyObject *repr_rdcarray_of_DescriptorStoreDescription(PyObject *self)
{
  rdcarray<DescriptorStoreDescription> *thisptr = array_thisptr<rdcarray<DescriptorStoreDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_DescriptorStoreDescription(PyObject *self, Py_ssize_t idx)
{
  rdcarray<DescriptorStoreDescription> *thisptr = array_thisptr<rdcarray<DescriptorStoreDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_DescriptorStoreDescription(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<DescriptorStoreDescription> *thisptr = array_thisptr<rdcarray<DescriptorStoreDescription>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_DescriptorStoreDescription(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<DescriptorStoreDescription> *thisptr = array_thisptr<rdcarray<DescriptorStoreDescription>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_DescriptorStoreDescription(PyObject *self, PyObject *idx)
{
  rdcarray<DescriptorStoreDescription> *thisptr = array_thisptr<rdcarray<DescriptorStoreDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_DescriptorStoreDescription(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<DescriptorStoreDescription> *thisptr = array_thisptr<rdcarray<DescriptorStoreDescription>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_DescriptorStoreDescription(PyObject *self, PyObject *vals)
{
  rdcarray<DescriptorStoreDescription> *thisptr = array_thisptr<rdcarray<DescriptorStoreDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_DescriptorStoreDescription(PyObject *self, Py_ssize_t count)
{
  rdcarray<DescriptorStoreDescription> *thisptr = array_thisptr<rdcarray<DescriptorStoreDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_DescriptorStoreDescription(PyObject *self, PyObject *vals)
{
  rdcarray<DescriptorStoreDescription> *thisptr = array_thisptr<rdcarray<DescriptorStoreDescription>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_DescriptorStoreDescription(PyObject *self, Py_ssize_t count)
{
  rdcarray<DescriptorStoreDescription> *thisptr = array_thisptr<rdcarray<DescriptorStoreDescription>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_BufferDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_BufferDescription",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_BufferDescription' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_BufferDescription' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  rdcarray< BufferDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription___eq__' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription___eq__' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription___eq__' argument 2 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription___eq__' argument 2 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< BufferDescription > const *)arg1)->operator ==((rdcarray< BufferDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  rdcarray< BufferDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription___ne__' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription___ne__' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription___ne__' argument 2 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription___ne__' argument 2 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< BufferDescription > const *)arg1)->operator !=((rdcarray< BufferDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  rdcarray< BufferDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription___lt__' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription___lt__' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription___lt__' argument 2 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription___lt__' argument 2 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< BufferDescription > const *)arg1)->operator <((rdcarray< BufferDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_resize_for_index' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_resize_for_index' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_BufferDescription_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  size_t arg2 ;
  BufferDescription *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_BufferDescription_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_fill' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_fill' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_BufferDescription_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_BufferDescription,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_BufferDescription_fill" "', argument " "3"" of type '" "BufferDescription const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_BufferDescription_fill" "', argument " "3"" of type '" "BufferDescription const &""'"); 
  }
  arg3 = reinterpret_cast< BufferDescription * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(BufferDescription const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_BufferDescription_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_pop_back' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_pop_back' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  SwigValueWrapper< std::function< bool (BufferDescription const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_removeIf' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_removeIf' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (BufferDescription const &) >>("rdcarray_of_BufferDescription_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  SwigValueWrapper< std::function< bool (BufferDescription const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_removeOneIf' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_removeOneIf' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (BufferDescription const &) >>("rdcarray_of_BufferDescription_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_append' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_append' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BufferDescription_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_BufferDescription_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_clear' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_clear' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BufferDescription_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_BufferDescription_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_insert' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_insert' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BufferDescription_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_BufferDescription_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_pop' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_pop' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BufferDescription_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_BufferDescription_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_sort' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_sort' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_BufferDescription_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BufferDescription_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_BufferDescription_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_copy' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_copy' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BufferDescription_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_BufferDescription_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_reverse' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_reverse' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BufferDescription_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_BufferDescription_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_index' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_index' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BufferDescription_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_count' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_count' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BufferDescription_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_extend' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_extend' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BufferDescription_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BufferDescription_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BufferDescription > *arg1 = (rdcarray< BufferDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BufferDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BufferDescription_remove' argument 1 of type 'rdcarray< BufferDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BufferDescription_remove' argument 1 of type 'rdcarray< BufferDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BufferDescription_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_BufferDescription) /* defines _wrap_delete_rdcarray_of_BufferDescription_destructor_closure */


PyObject *repr_rdcarray_of_BufferDescription(PyObject *self)
{
  rdcarray<BufferDescription> *thisptr = array_thisptr<rdcarray<BufferDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_BufferDescription(PyObject *self, Py_ssize_t idx)
{
  rdcarray<BufferDescription> *thisptr = array_thisptr<rdcarray<BufferDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_BufferDescription(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<BufferDescription> *thisptr = array_thisptr<rdcarray<BufferDescription>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_BufferDescription(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<BufferDescription> *thisptr = array_thisptr<rdcarray<BufferDescription>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_BufferDescription(PyObject *self, PyObject *idx)
{
  rdcarray<BufferDescription> *thisptr = array_thisptr<rdcarray<BufferDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_BufferDescription(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<BufferDescription> *thisptr = array_thisptr<rdcarray<BufferDescription>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_BufferDescription(PyObject *self, PyObject *vals)
{
  rdcarray<BufferDescription> *thisptr = array_thisptr<rdcarray<BufferDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_BufferDescription(PyObject *self, Py_ssize_t count)
{
  rdcarray<BufferDescription> *thisptr = array_thisptr<rdcarray<BufferDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_BufferDescription(PyObject *self, PyObject *vals)
{
  rdcarray<BufferDescription> *thisptr = array_thisptr<rdcarray<BufferDescription>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_BufferDescription(PyObject *self, Py_ssize_t count)
{
  rdcarray<BufferDescription> *thisptr = array_thisptr<rdcarray<BufferDescription>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_CaptureFileFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_CaptureFileFormat",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_CaptureFileFormat' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_CaptureFileFormat' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  rdcarray< CaptureFileFormat > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat___eq__' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat___eq__' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat___eq__' argument 2 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat___eq__' argument 2 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< CaptureFileFormat > const *)arg1)->operator ==((rdcarray< CaptureFileFormat > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  rdcarray< CaptureFileFormat > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat___ne__' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat___ne__' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat___ne__' argument 2 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat___ne__' argument 2 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< CaptureFileFormat > const *)arg1)->operator !=((rdcarray< CaptureFileFormat > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  rdcarray< CaptureFileFormat > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat___lt__' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat___lt__' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat___lt__' argument 2 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat___lt__' argument 2 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< CaptureFileFormat > const *)arg1)->operator <((rdcarray< CaptureFileFormat > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_resize_for_index' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_resize_for_index' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_CaptureFileFormat_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  size_t arg2 ;
  CaptureFileFormat *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_CaptureFileFormat_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_fill' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_fill' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_CaptureFileFormat_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_CaptureFileFormat,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_CaptureFileFormat_fill" "', argument " "3"" of type '" "CaptureFileFormat const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_CaptureFileFormat_fill" "', argument " "3"" of type '" "CaptureFileFormat const &""'"); 
  }
  arg3 = reinterpret_cast< CaptureFileFormat * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(CaptureFileFormat const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_CaptureFileFormat_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_pop_back' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_pop_back' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  SwigValueWrapper< std::function< bool (CaptureFileFormat const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_removeIf' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_removeIf' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (CaptureFileFormat const &) >>("rdcarray_of_CaptureFileFormat_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  SwigValueWrapper< std::function< bool (CaptureFileFormat const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_removeOneIf' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_removeOneIf' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (CaptureFileFormat const &) >>("rdcarray_of_CaptureFileFormat_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_append' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_append' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CaptureFileFormat_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_CaptureFileFormat_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_clear' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_clear' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CaptureFileFormat_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_CaptureFileFormat_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_insert' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_insert' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CaptureFileFormat_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_CaptureFileFormat_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_pop' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_pop' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CaptureFileFormat_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_CaptureFileFormat_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_sort' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_sort' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_CaptureFileFormat_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CaptureFileFormat_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_CaptureFileFormat_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_copy' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_copy' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CaptureFileFormat_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_CaptureFileFormat_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_reverse' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_reverse' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CaptureFileFormat_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_CaptureFileFormat_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_index' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_index' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CaptureFileFormat_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_count' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_count' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CaptureFileFormat_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_extend' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_extend' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CaptureFileFormat_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_CaptureFileFormat_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< CaptureFileFormat > *arg1 = (rdcarray< CaptureFileFormat > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< CaptureFileFormat >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_CaptureFileFormat_remove' argument 1 of type 'rdcarray< CaptureFileFormat >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_CaptureFileFormat_remove' argument 1 of type 'rdcarray< CaptureFileFormat >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_CaptureFileFormat_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_CaptureFileFormat) /* defines _wrap_delete_rdcarray_of_CaptureFileFormat_destructor_closure */


PyObject *repr_rdcarray_of_CaptureFileFormat(PyObject *self)
{
  rdcarray<CaptureFileFormat> *thisptr = array_thisptr<rdcarray<CaptureFileFormat>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_CaptureFileFormat(PyObject *self, Py_ssize_t idx)
{
  rdcarray<CaptureFileFormat> *thisptr = array_thisptr<rdcarray<CaptureFileFormat>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_CaptureFileFormat(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<CaptureFileFormat> *thisptr = array_thisptr<rdcarray<CaptureFileFormat>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_CaptureFileFormat(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<CaptureFileFormat> *thisptr = array_thisptr<rdcarray<CaptureFileFormat>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_CaptureFileFormat(PyObject *self, PyObject *idx)
{
  rdcarray<CaptureFileFormat> *thisptr = array_thisptr<rdcarray<CaptureFileFormat>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_CaptureFileFormat(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<CaptureFileFormat> *thisptr = array_thisptr<rdcarray<CaptureFileFormat>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_CaptureFileFormat(PyObject *self, PyObject *vals)
{
  rdcarray<CaptureFileFormat> *thisptr = array_thisptr<rdcarray<CaptureFileFormat>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_CaptureFileFormat(PyObject *self, Py_ssize_t count)
{
  rdcarray<CaptureFileFormat> *thisptr = array_thisptr<rdcarray<CaptureFileFormat>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_CaptureFileFormat(PyObject *self, PyObject *vals)
{
  rdcarray<CaptureFileFormat> *thisptr = array_thisptr<rdcarray<CaptureFileFormat>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_CaptureFileFormat(PyObject *self, Py_ssize_t count)
{
  rdcarray<CaptureFileFormat> *thisptr = array_thisptr<rdcarray<CaptureFileFormat>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ConstantBlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ConstantBlock",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ConstantBlock' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ConstantBlock' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  rdcarray< ConstantBlock > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock___eq__' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock___eq__' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock___eq__' argument 2 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock___eq__' argument 2 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ConstantBlock > const *)arg1)->operator ==((rdcarray< ConstantBlock > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  rdcarray< ConstantBlock > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock___ne__' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock___ne__' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock___ne__' argument 2 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock___ne__' argument 2 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ConstantBlock > const *)arg1)->operator !=((rdcarray< ConstantBlock > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  rdcarray< ConstantBlock > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock___lt__' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock___lt__' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock___lt__' argument 2 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock___lt__' argument 2 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ConstantBlock > const *)arg1)->operator <((rdcarray< ConstantBlock > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_resize_for_index' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_resize_for_index' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ConstantBlock_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  size_t arg2 ;
  ConstantBlock *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ConstantBlock_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_fill' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_fill' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ConstantBlock_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ConstantBlock,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ConstantBlock_fill" "', argument " "3"" of type '" "ConstantBlock const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ConstantBlock_fill" "', argument " "3"" of type '" "ConstantBlock const &""'"); 
  }
  arg3 = reinterpret_cast< ConstantBlock * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ConstantBlock const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ConstantBlock_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_pop_back' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_pop_back' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  SwigValueWrapper< std::function< bool (ConstantBlock const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_removeIf' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_removeIf' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ConstantBlock const &) >>("rdcarray_of_ConstantBlock_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  SwigValueWrapper< std::function< bool (ConstantBlock const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_removeOneIf' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_removeOneIf' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ConstantBlock const &) >>("rdcarray_of_ConstantBlock_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_append' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_append' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBlock_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ConstantBlock_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_clear' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_clear' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBlock_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ConstantBlock_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_insert' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_insert' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBlock_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ConstantBlock_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_pop' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_pop' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBlock_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ConstantBlock_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_sort' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_sort' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ConstantBlock_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBlock_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ConstantBlock_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_copy' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_copy' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBlock_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ConstantBlock_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_reverse' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_reverse' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBlock_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ConstantBlock_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_index' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_index' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBlock_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_count' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_count' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBlock_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_extend' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_extend' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBlock_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBlock_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBlock > *arg1 = (rdcarray< ConstantBlock > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBlock >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBlock_remove' argument 1 of type 'rdcarray< ConstantBlock >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBlock_remove' argument 1 of type 'rdcarray< ConstantBlock >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBlock_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ConstantBlock) /* defines _wrap_delete_rdcarray_of_ConstantBlock_destructor_closure */


PyObject *repr_rdcarray_of_ConstantBlock(PyObject *self)
{
  rdcarray<ConstantBlock> *thisptr = array_thisptr<rdcarray<ConstantBlock>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ConstantBlock(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ConstantBlock> *thisptr = array_thisptr<rdcarray<ConstantBlock>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ConstantBlock(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ConstantBlock> *thisptr = array_thisptr<rdcarray<ConstantBlock>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ConstantBlock(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ConstantBlock> *thisptr = array_thisptr<rdcarray<ConstantBlock>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ConstantBlock(PyObject *self, PyObject *idx)
{
  rdcarray<ConstantBlock> *thisptr = array_thisptr<rdcarray<ConstantBlock>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ConstantBlock(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ConstantBlock> *thisptr = array_thisptr<rdcarray<ConstantBlock>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ConstantBlock(PyObject *self, PyObject *vals)
{
  rdcarray<ConstantBlock> *thisptr = array_thisptr<rdcarray<ConstantBlock>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ConstantBlock(PyObject *self, Py_ssize_t count)
{
  rdcarray<ConstantBlock> *thisptr = array_thisptr<rdcarray<ConstantBlock>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ConstantBlock(PyObject *self, PyObject *vals)
{
  rdcarray<ConstantBlock> *thisptr = array_thisptr<rdcarray<ConstantBlock>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ConstantBlock(PyObject *self, Py_ssize_t count)
{
  rdcarray<ConstantBlock> *thisptr = array_thisptr<rdcarray<ConstantBlock>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_DebugMessage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_DebugMessage",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_DebugMessage' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_DebugMessage' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  rdcarray< DebugMessage > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage___eq__' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage___eq__' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage___eq__' argument 2 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage___eq__' argument 2 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DebugMessage > const *)arg1)->operator ==((rdcarray< DebugMessage > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  rdcarray< DebugMessage > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage___ne__' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage___ne__' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage___ne__' argument 2 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage___ne__' argument 2 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DebugMessage > const *)arg1)->operator !=((rdcarray< DebugMessage > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  rdcarray< DebugMessage > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage___lt__' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage___lt__' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage___lt__' argument 2 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage___lt__' argument 2 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DebugMessage > const *)arg1)->operator <((rdcarray< DebugMessage > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_resize_for_index' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_resize_for_index' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_DebugMessage_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  size_t arg2 ;
  DebugMessage *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DebugMessage_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_fill' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_fill' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_DebugMessage_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_DebugMessage,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_DebugMessage_fill" "', argument " "3"" of type '" "DebugMessage const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_DebugMessage_fill" "', argument " "3"" of type '" "DebugMessage const &""'"); 
  }
  arg3 = reinterpret_cast< DebugMessage * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(DebugMessage const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DebugMessage_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_pop_back' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_pop_back' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  SwigValueWrapper< std::function< bool (DebugMessage const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_removeIf' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_removeIf' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (DebugMessage const &) >>("rdcarray_of_DebugMessage_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  SwigValueWrapper< std::function< bool (DebugMessage const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_removeOneIf' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_removeOneIf' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (DebugMessage const &) >>("rdcarray_of_DebugMessage_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_append' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_append' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugMessage_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DebugMessage_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_clear' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_clear' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugMessage_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DebugMessage_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_insert' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_insert' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugMessage_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_DebugMessage_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_pop' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_pop' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugMessage_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_DebugMessage_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_sort' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_sort' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_DebugMessage_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugMessage_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DebugMessage_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_copy' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_copy' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugMessage_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DebugMessage_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_reverse' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_reverse' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugMessage_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_DebugMessage_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_index' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_index' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugMessage_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_count' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_count' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugMessage_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_extend' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_extend' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugMessage_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugMessage_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugMessage > *arg1 = (rdcarray< DebugMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugMessage_remove' argument 1 of type 'rdcarray< DebugMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugMessage_remove' argument 1 of type 'rdcarray< DebugMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugMessage_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_DebugMessage) /* defines _wrap_delete_rdcarray_of_DebugMessage_destructor_closure */


PyObject *repr_rdcarray_of_DebugMessage(PyObject *self)
{
  rdcarray<DebugMessage> *thisptr = array_thisptr<rdcarray<DebugMessage>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_DebugMessage(PyObject *self, Py_ssize_t idx)
{
  rdcarray<DebugMessage> *thisptr = array_thisptr<rdcarray<DebugMessage>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_DebugMessage(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<DebugMessage> *thisptr = array_thisptr<rdcarray<DebugMessage>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_DebugMessage(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<DebugMessage> *thisptr = array_thisptr<rdcarray<DebugMessage>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_DebugMessage(PyObject *self, PyObject *idx)
{
  rdcarray<DebugMessage> *thisptr = array_thisptr<rdcarray<DebugMessage>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_DebugMessage(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<DebugMessage> *thisptr = array_thisptr<rdcarray<DebugMessage>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_DebugMessage(PyObject *self, PyObject *vals)
{
  rdcarray<DebugMessage> *thisptr = array_thisptr<rdcarray<DebugMessage>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_DebugMessage(PyObject *self, Py_ssize_t count)
{
  rdcarray<DebugMessage> *thisptr = array_thisptr<rdcarray<DebugMessage>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_DebugMessage(PyObject *self, PyObject *vals)
{
  rdcarray<DebugMessage> *thisptr = array_thisptr<rdcarray<DebugMessage>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_DebugMessage(PyObject *self, Py_ssize_t count)
{
  rdcarray<DebugMessage> *thisptr = array_thisptr<rdcarray<DebugMessage>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_EnvironmentModification(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_EnvironmentModification",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_EnvironmentModification' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_EnvironmentModification' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  rdcarray< EnvironmentModification > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification___eq__' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification___eq__' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification___eq__' argument 2 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification___eq__' argument 2 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< EnvironmentModification > const *)arg1)->operator ==((rdcarray< EnvironmentModification > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  rdcarray< EnvironmentModification > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification___ne__' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification___ne__' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification___ne__' argument 2 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification___ne__' argument 2 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< EnvironmentModification > const *)arg1)->operator !=((rdcarray< EnvironmentModification > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  rdcarray< EnvironmentModification > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification___lt__' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification___lt__' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification___lt__' argument 2 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification___lt__' argument 2 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< EnvironmentModification > const *)arg1)->operator <((rdcarray< EnvironmentModification > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_resize_for_index' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_resize_for_index' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_EnvironmentModification_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  size_t arg2 ;
  EnvironmentModification *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_EnvironmentModification_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_fill' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_fill' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_EnvironmentModification_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_EnvironmentModification,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_EnvironmentModification_fill" "', argument " "3"" of type '" "EnvironmentModification const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_EnvironmentModification_fill" "', argument " "3"" of type '" "EnvironmentModification const &""'"); 
  }
  arg3 = reinterpret_cast< EnvironmentModification * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(EnvironmentModification const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_EnvironmentModification_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_pop_back' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_pop_back' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  SwigValueWrapper< std::function< bool (EnvironmentModification const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_removeIf' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_removeIf' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (EnvironmentModification const &) >>("rdcarray_of_EnvironmentModification_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  SwigValueWrapper< std::function< bool (EnvironmentModification const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_removeOneIf' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_removeOneIf' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (EnvironmentModification const &) >>("rdcarray_of_EnvironmentModification_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_append' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_append' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EnvironmentModification_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_EnvironmentModification_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_clear' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_clear' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EnvironmentModification_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_EnvironmentModification_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_insert' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_insert' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EnvironmentModification_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_EnvironmentModification_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_pop' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_pop' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EnvironmentModification_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_EnvironmentModification_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_sort' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_sort' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_EnvironmentModification_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EnvironmentModification_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_EnvironmentModification_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_copy' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_copy' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EnvironmentModification_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_EnvironmentModification_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_reverse' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_reverse' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EnvironmentModification_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_EnvironmentModification_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_index' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_index' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EnvironmentModification_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_count' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_count' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EnvironmentModification_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_extend' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_extend' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EnvironmentModification_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EnvironmentModification_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EnvironmentModification > *arg1 = (rdcarray< EnvironmentModification > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EnvironmentModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EnvironmentModification_remove' argument 1 of type 'rdcarray< EnvironmentModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EnvironmentModification_remove' argument 1 of type 'rdcarray< EnvironmentModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EnvironmentModification_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_EnvironmentModification) /* defines _wrap_delete_rdcarray_of_EnvironmentModification_destructor_closure */


PyObject *repr_rdcarray_of_EnvironmentModification(PyObject *self)
{
  rdcarray<EnvironmentModification> *thisptr = array_thisptr<rdcarray<EnvironmentModification>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_EnvironmentModification(PyObject *self, Py_ssize_t idx)
{
  rdcarray<EnvironmentModification> *thisptr = array_thisptr<rdcarray<EnvironmentModification>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_EnvironmentModification(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<EnvironmentModification> *thisptr = array_thisptr<rdcarray<EnvironmentModification>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_EnvironmentModification(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<EnvironmentModification> *thisptr = array_thisptr<rdcarray<EnvironmentModification>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_EnvironmentModification(PyObject *self, PyObject *idx)
{
  rdcarray<EnvironmentModification> *thisptr = array_thisptr<rdcarray<EnvironmentModification>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_EnvironmentModification(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<EnvironmentModification> *thisptr = array_thisptr<rdcarray<EnvironmentModification>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_EnvironmentModification(PyObject *self, PyObject *vals)
{
  rdcarray<EnvironmentModification> *thisptr = array_thisptr<rdcarray<EnvironmentModification>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_EnvironmentModification(PyObject *self, Py_ssize_t count)
{
  rdcarray<EnvironmentModification> *thisptr = array_thisptr<rdcarray<EnvironmentModification>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_EnvironmentModification(PyObject *self, PyObject *vals)
{
  rdcarray<EnvironmentModification> *thisptr = array_thisptr<rdcarray<EnvironmentModification>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_EnvironmentModification(PyObject *self, Py_ssize_t count)
{
  rdcarray<EnvironmentModification> *thisptr = array_thisptr<rdcarray<EnvironmentModification>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_EventUsage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_EventUsage",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_EventUsage' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_EventUsage' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  rdcarray< EventUsage > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage___eq__' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage___eq__' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage___eq__' argument 2 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage___eq__' argument 2 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< EventUsage > const *)arg1)->operator ==((rdcarray< EventUsage > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  rdcarray< EventUsage > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage___ne__' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage___ne__' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage___ne__' argument 2 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage___ne__' argument 2 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< EventUsage > const *)arg1)->operator !=((rdcarray< EventUsage > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  rdcarray< EventUsage > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage___lt__' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage___lt__' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage___lt__' argument 2 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage___lt__' argument 2 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< EventUsage > const *)arg1)->operator <((rdcarray< EventUsage > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_resize_for_index' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_resize_for_index' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_EventUsage_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  size_t arg2 ;
  EventUsage *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_EventUsage_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_fill' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_fill' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_EventUsage_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_EventUsage,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_EventUsage_fill" "', argument " "3"" of type '" "EventUsage const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_EventUsage_fill" "', argument " "3"" of type '" "EventUsage const &""'"); 
  }
  arg3 = reinterpret_cast< EventUsage * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(EventUsage const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_EventUsage_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_pop_back' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_pop_back' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  SwigValueWrapper< std::function< bool (EventUsage const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_removeIf' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_removeIf' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (EventUsage const &) >>("rdcarray_of_EventUsage_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  SwigValueWrapper< std::function< bool (EventUsage const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_removeOneIf' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_removeOneIf' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (EventUsage const &) >>("rdcarray_of_EventUsage_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_append' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_append' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EventUsage_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_EventUsage_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_clear' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_clear' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EventUsage_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_EventUsage_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_insert' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_insert' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EventUsage_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_EventUsage_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_pop' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_pop' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EventUsage_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_EventUsage_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_sort' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_sort' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_EventUsage_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EventUsage_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_EventUsage_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_copy' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_copy' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EventUsage_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_EventUsage_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_reverse' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_reverse' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EventUsage_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_EventUsage_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_index' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_index' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EventUsage_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_count' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_count' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EventUsage_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_extend' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_extend' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EventUsage_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_EventUsage_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< EventUsage > *arg1 = (rdcarray< EventUsage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< EventUsage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_EventUsage_remove' argument 1 of type 'rdcarray< EventUsage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_EventUsage_remove' argument 1 of type 'rdcarray< EventUsage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_EventUsage_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_EventUsage) /* defines _wrap_delete_rdcarray_of_EventUsage_destructor_closure */


PyObject *repr_rdcarray_of_EventUsage(PyObject *self)
{
  rdcarray<EventUsage> *thisptr = array_thisptr<rdcarray<EventUsage>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_EventUsage(PyObject *self, Py_ssize_t idx)
{
  rdcarray<EventUsage> *thisptr = array_thisptr<rdcarray<EventUsage>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_EventUsage(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<EventUsage> *thisptr = array_thisptr<rdcarray<EventUsage>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_EventUsage(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<EventUsage> *thisptr = array_thisptr<rdcarray<EventUsage>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_EventUsage(PyObject *self, PyObject *idx)
{
  rdcarray<EventUsage> *thisptr = array_thisptr<rdcarray<EventUsage>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_EventUsage(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<EventUsage> *thisptr = array_thisptr<rdcarray<EventUsage>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_EventUsage(PyObject *self, PyObject *vals)
{
  rdcarray<EventUsage> *thisptr = array_thisptr<rdcarray<EventUsage>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_EventUsage(PyObject *self, Py_ssize_t count)
{
  rdcarray<EventUsage> *thisptr = array_thisptr<rdcarray<EventUsage>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_EventUsage(PyObject *self, PyObject *vals)
{
  rdcarray<EventUsage> *thisptr = array_thisptr<rdcarray<EventUsage>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_EventUsage(PyObject *self, Py_ssize_t count)
{
  rdcarray<EventUsage> *thisptr = array_thisptr<rdcarray<EventUsage>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_PathEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_PathEntry",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_PathEntry' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_PathEntry' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  rdcarray< PathEntry > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry___eq__' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry___eq__' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry___eq__' argument 2 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry___eq__' argument 2 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< PathEntry > const *)arg1)->operator ==((rdcarray< PathEntry > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  rdcarray< PathEntry > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry___ne__' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry___ne__' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry___ne__' argument 2 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry___ne__' argument 2 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< PathEntry > const *)arg1)->operator !=((rdcarray< PathEntry > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  rdcarray< PathEntry > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry___lt__' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry___lt__' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry___lt__' argument 2 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry___lt__' argument 2 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< PathEntry > const *)arg1)->operator <((rdcarray< PathEntry > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_resize_for_index' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_resize_for_index' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_PathEntry_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  size_t arg2 ;
  PathEntry *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_PathEntry_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_fill' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_fill' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_PathEntry_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_PathEntry,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_PathEntry_fill" "', argument " "3"" of type '" "PathEntry const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_PathEntry_fill" "', argument " "3"" of type '" "PathEntry const &""'"); 
  }
  arg3 = reinterpret_cast< PathEntry * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(PathEntry const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_PathEntry_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_pop_back' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_pop_back' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  SwigValueWrapper< std::function< bool (PathEntry const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_removeIf' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_removeIf' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (PathEntry const &) >>("rdcarray_of_PathEntry_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  SwigValueWrapper< std::function< bool (PathEntry const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_removeOneIf' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_removeOneIf' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (PathEntry const &) >>("rdcarray_of_PathEntry_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_append' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_append' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PathEntry_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_PathEntry_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_clear' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_clear' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PathEntry_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_PathEntry_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_insert' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_insert' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PathEntry_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_PathEntry_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_pop' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_pop' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PathEntry_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_PathEntry_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_sort' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_sort' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_PathEntry_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PathEntry_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_PathEntry_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_copy' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_copy' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PathEntry_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_PathEntry_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_reverse' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_reverse' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PathEntry_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_PathEntry_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_index' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_index' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PathEntry_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_count' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_count' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PathEntry_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_extend' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_extend' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PathEntry_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PathEntry_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PathEntry > *arg1 = (rdcarray< PathEntry > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PathEntry >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PathEntry_remove' argument 1 of type 'rdcarray< PathEntry >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PathEntry_remove' argument 1 of type 'rdcarray< PathEntry >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PathEntry_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_PathEntry) /* defines _wrap_delete_rdcarray_of_PathEntry_destructor_closure */


PyObject *repr_rdcarray_of_PathEntry(PyObject *self)
{
  rdcarray<PathEntry> *thisptr = array_thisptr<rdcarray<PathEntry>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_PathEntry(PyObject *self, Py_ssize_t idx)
{
  rdcarray<PathEntry> *thisptr = array_thisptr<rdcarray<PathEntry>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_PathEntry(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<PathEntry> *thisptr = array_thisptr<rdcarray<PathEntry>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_PathEntry(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<PathEntry> *thisptr = array_thisptr<rdcarray<PathEntry>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_PathEntry(PyObject *self, PyObject *idx)
{
  rdcarray<PathEntry> *thisptr = array_thisptr<rdcarray<PathEntry>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_PathEntry(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<PathEntry> *thisptr = array_thisptr<rdcarray<PathEntry>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_PathEntry(PyObject *self, PyObject *vals)
{
  rdcarray<PathEntry> *thisptr = array_thisptr<rdcarray<PathEntry>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_PathEntry(PyObject *self, Py_ssize_t count)
{
  rdcarray<PathEntry> *thisptr = array_thisptr<rdcarray<PathEntry>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_PathEntry(PyObject *self, PyObject *vals)
{
  rdcarray<PathEntry> *thisptr = array_thisptr<rdcarray<PathEntry>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_PathEntry(PyObject *self, Py_ssize_t count)
{
  rdcarray<PathEntry> *thisptr = array_thisptr<rdcarray<PathEntry>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_PixelModification(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_PixelModification",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_PixelModification' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_PixelModification' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  rdcarray< PixelModification > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification___eq__' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification___eq__' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification___eq__' argument 2 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification___eq__' argument 2 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< PixelModification > const *)arg1)->operator ==((rdcarray< PixelModification > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  rdcarray< PixelModification > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification___ne__' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification___ne__' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification___ne__' argument 2 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification___ne__' argument 2 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< PixelModification > const *)arg1)->operator !=((rdcarray< PixelModification > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  rdcarray< PixelModification > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification___lt__' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification___lt__' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification___lt__' argument 2 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification___lt__' argument 2 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< PixelModification > const *)arg1)->operator <((rdcarray< PixelModification > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_resize_for_index' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_resize_for_index' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_PixelModification_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  size_t arg2 ;
  PixelModification *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_PixelModification_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_fill' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_fill' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_PixelModification_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_PixelModification,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_PixelModification_fill" "', argument " "3"" of type '" "PixelModification const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_PixelModification_fill" "', argument " "3"" of type '" "PixelModification const &""'"); 
  }
  arg3 = reinterpret_cast< PixelModification * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(PixelModification const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_PixelModification_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_pop_back' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_pop_back' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  SwigValueWrapper< std::function< bool (PixelModification const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_removeIf' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_removeIf' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (PixelModification const &) >>("rdcarray_of_PixelModification_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  SwigValueWrapper< std::function< bool (PixelModification const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_removeOneIf' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_removeOneIf' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (PixelModification const &) >>("rdcarray_of_PixelModification_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_append' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_append' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PixelModification_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_PixelModification_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_clear' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_clear' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PixelModification_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_PixelModification_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_insert' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_insert' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PixelModification_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_PixelModification_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_pop' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_pop' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PixelModification_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_PixelModification_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_sort' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_sort' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_PixelModification_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PixelModification_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_PixelModification_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_copy' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_copy' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PixelModification_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_PixelModification_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_reverse' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_reverse' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PixelModification_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_PixelModification_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_index' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_index' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PixelModification_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_count' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_count' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PixelModification_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_extend' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_extend' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PixelModification_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_PixelModification_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< PixelModification > *arg1 = (rdcarray< PixelModification > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< PixelModification >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_PixelModification_remove' argument 1 of type 'rdcarray< PixelModification >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_PixelModification_remove' argument 1 of type 'rdcarray< PixelModification >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_PixelModification_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_PixelModification) /* defines _wrap_delete_rdcarray_of_PixelModification_destructor_closure */


PyObject *repr_rdcarray_of_PixelModification(PyObject *self)
{
  rdcarray<PixelModification> *thisptr = array_thisptr<rdcarray<PixelModification>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_PixelModification(PyObject *self, Py_ssize_t idx)
{
  rdcarray<PixelModification> *thisptr = array_thisptr<rdcarray<PixelModification>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_PixelModification(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<PixelModification> *thisptr = array_thisptr<rdcarray<PixelModification>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_PixelModification(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<PixelModification> *thisptr = array_thisptr<rdcarray<PixelModification>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_PixelModification(PyObject *self, PyObject *idx)
{
  rdcarray<PixelModification> *thisptr = array_thisptr<rdcarray<PixelModification>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_PixelModification(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<PixelModification> *thisptr = array_thisptr<rdcarray<PixelModification>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_PixelModification(PyObject *self, PyObject *vals)
{
  rdcarray<PixelModification> *thisptr = array_thisptr<rdcarray<PixelModification>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_PixelModification(PyObject *self, Py_ssize_t count)
{
  rdcarray<PixelModification> *thisptr = array_thisptr<rdcarray<PixelModification>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_PixelModification(PyObject *self, PyObject *vals)
{
  rdcarray<PixelModification> *thisptr = array_thisptr<rdcarray<PixelModification>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_PixelModification(PyObject *self, Py_ssize_t count)
{
  rdcarray<PixelModification> *thisptr = array_thisptr<rdcarray<PixelModification>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_TaskGroupSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_TaskGroupSize",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_TaskGroupSize' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_TaskGroupSize' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  rdcarray< TaskGroupSize > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize___eq__' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize___eq__' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize___eq__' argument 2 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize___eq__' argument 2 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< TaskGroupSize > const *)arg1)->operator ==((rdcarray< TaskGroupSize > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  rdcarray< TaskGroupSize > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize___ne__' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize___ne__' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize___ne__' argument 2 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize___ne__' argument 2 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< TaskGroupSize > const *)arg1)->operator !=((rdcarray< TaskGroupSize > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  rdcarray< TaskGroupSize > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize___lt__' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize___lt__' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize___lt__' argument 2 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize___lt__' argument 2 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< TaskGroupSize > const *)arg1)->operator <((rdcarray< TaskGroupSize > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_resize_for_index' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_resize_for_index' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_TaskGroupSize_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  size_t arg2 ;
  TaskGroupSize *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_TaskGroupSize_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_fill' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_fill' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_TaskGroupSize_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_TaskGroupSize,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_TaskGroupSize_fill" "', argument " "3"" of type '" "TaskGroupSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_TaskGroupSize_fill" "', argument " "3"" of type '" "TaskGroupSize const &""'"); 
  }
  arg3 = reinterpret_cast< TaskGroupSize * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(TaskGroupSize const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_TaskGroupSize_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_pop_back' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_pop_back' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  SwigValueWrapper< std::function< bool (TaskGroupSize const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_removeIf' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_removeIf' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (TaskGroupSize const &) >>("rdcarray_of_TaskGroupSize_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  SwigValueWrapper< std::function< bool (TaskGroupSize const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_removeOneIf' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_removeOneIf' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (TaskGroupSize const &) >>("rdcarray_of_TaskGroupSize_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_append' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_append' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TaskGroupSize_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_TaskGroupSize_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_clear' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_clear' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TaskGroupSize_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_TaskGroupSize_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_insert' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_insert' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TaskGroupSize_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_TaskGroupSize_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_pop' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_pop' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TaskGroupSize_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_TaskGroupSize_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_sort' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_sort' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_TaskGroupSize_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TaskGroupSize_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_TaskGroupSize_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_copy' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_copy' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TaskGroupSize_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_TaskGroupSize_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_reverse' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_reverse' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TaskGroupSize_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_TaskGroupSize_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_index' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_index' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TaskGroupSize_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_count' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_count' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TaskGroupSize_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_extend' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_extend' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TaskGroupSize_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TaskGroupSize_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TaskGroupSize > *arg1 = (rdcarray< TaskGroupSize > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TaskGroupSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TaskGroupSize_remove' argument 1 of type 'rdcarray< TaskGroupSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TaskGroupSize_remove' argument 1 of type 'rdcarray< TaskGroupSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TaskGroupSize_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_TaskGroupSize) /* defines _wrap_delete_rdcarray_of_TaskGroupSize_destructor_closure */


PyObject *repr_rdcarray_of_TaskGroupSize(PyObject *self)
{
  rdcarray<TaskGroupSize> *thisptr = array_thisptr<rdcarray<TaskGroupSize>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_TaskGroupSize(PyObject *self, Py_ssize_t idx)
{
  rdcarray<TaskGroupSize> *thisptr = array_thisptr<rdcarray<TaskGroupSize>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_TaskGroupSize(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<TaskGroupSize> *thisptr = array_thisptr<rdcarray<TaskGroupSize>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_TaskGroupSize(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<TaskGroupSize> *thisptr = array_thisptr<rdcarray<TaskGroupSize>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_TaskGroupSize(PyObject *self, PyObject *idx)
{
  rdcarray<TaskGroupSize> *thisptr = array_thisptr<rdcarray<TaskGroupSize>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_TaskGroupSize(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<TaskGroupSize> *thisptr = array_thisptr<rdcarray<TaskGroupSize>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_TaskGroupSize(PyObject *self, PyObject *vals)
{
  rdcarray<TaskGroupSize> *thisptr = array_thisptr<rdcarray<TaskGroupSize>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_TaskGroupSize(PyObject *self, Py_ssize_t count)
{
  rdcarray<TaskGroupSize> *thisptr = array_thisptr<rdcarray<TaskGroupSize>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_TaskGroupSize(PyObject *self, PyObject *vals)
{
  rdcarray<TaskGroupSize> *thisptr = array_thisptr<rdcarray<TaskGroupSize>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_TaskGroupSize(PyObject *self, Py_ssize_t count)
{
  rdcarray<TaskGroupSize> *thisptr = array_thisptr<rdcarray<TaskGroupSize>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_MeshletSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_MeshletSize",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_MeshletSize' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_MeshletSize' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  rdcarray< MeshletSize > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize___eq__' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize___eq__' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize___eq__' argument 2 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize___eq__' argument 2 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< MeshletSize > const *)arg1)->operator ==((rdcarray< MeshletSize > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  rdcarray< MeshletSize > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize___ne__' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize___ne__' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize___ne__' argument 2 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize___ne__' argument 2 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< MeshletSize > const *)arg1)->operator !=((rdcarray< MeshletSize > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  rdcarray< MeshletSize > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize___lt__' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize___lt__' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize___lt__' argument 2 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize___lt__' argument 2 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< MeshletSize > const *)arg1)->operator <((rdcarray< MeshletSize > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_resize_for_index' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_resize_for_index' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_MeshletSize_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  size_t arg2 ;
  MeshletSize *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_MeshletSize_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_fill' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_fill' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_MeshletSize_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_MeshletSize,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_MeshletSize_fill" "', argument " "3"" of type '" "MeshletSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_MeshletSize_fill" "', argument " "3"" of type '" "MeshletSize const &""'"); 
  }
  arg3 = reinterpret_cast< MeshletSize * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(MeshletSize const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_MeshletSize_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_pop_back' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_pop_back' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  SwigValueWrapper< std::function< bool (MeshletSize const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_removeIf' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_removeIf' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (MeshletSize const &) >>("rdcarray_of_MeshletSize_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  SwigValueWrapper< std::function< bool (MeshletSize const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_removeOneIf' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_removeOneIf' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (MeshletSize const &) >>("rdcarray_of_MeshletSize_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_append' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_append' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_MeshletSize_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_MeshletSize_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_clear' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_clear' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_MeshletSize_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_MeshletSize_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_insert' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_insert' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_MeshletSize_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_MeshletSize_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_pop' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_pop' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_MeshletSize_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_MeshletSize_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_sort' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_sort' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_MeshletSize_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_MeshletSize_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_MeshletSize_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_copy' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_copy' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_MeshletSize_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_MeshletSize_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_reverse' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_reverse' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_MeshletSize_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_MeshletSize_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_index' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_index' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_MeshletSize_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_count' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_count' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_MeshletSize_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_extend' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_extend' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_MeshletSize_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_MeshletSize_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< MeshletSize > *arg1 = (rdcarray< MeshletSize > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< MeshletSize >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_MeshletSize_remove' argument 1 of type 'rdcarray< MeshletSize >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_MeshletSize_remove' argument 1 of type 'rdcarray< MeshletSize >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_MeshletSize_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_MeshletSize) /* defines _wrap_delete_rdcarray_of_MeshletSize_destructor_closure */


PyObject *repr_rdcarray_of_MeshletSize(PyObject *self)
{
  rdcarray<MeshletSize> *thisptr = array_thisptr<rdcarray<MeshletSize>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_MeshletSize(PyObject *self, Py_ssize_t idx)
{
  rdcarray<MeshletSize> *thisptr = array_thisptr<rdcarray<MeshletSize>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_MeshletSize(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<MeshletSize> *thisptr = array_thisptr<rdcarray<MeshletSize>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_MeshletSize(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<MeshletSize> *thisptr = array_thisptr<rdcarray<MeshletSize>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_MeshletSize(PyObject *self, PyObject *idx)
{
  rdcarray<MeshletSize> *thisptr = array_thisptr<rdcarray<MeshletSize>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_MeshletSize(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<MeshletSize> *thisptr = array_thisptr<rdcarray<MeshletSize>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_MeshletSize(PyObject *self, PyObject *vals)
{
  rdcarray<MeshletSize> *thisptr = array_thisptr<rdcarray<MeshletSize>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_MeshletSize(PyObject *self, Py_ssize_t count)
{
  rdcarray<MeshletSize> *thisptr = array_thisptr<rdcarray<MeshletSize>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_MeshletSize(PyObject *self, PyObject *vals)
{
  rdcarray<MeshletSize> *thisptr = array_thisptr<rdcarray<MeshletSize>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_MeshletSize(PyObject *self, Py_ssize_t count)
{
  rdcarray<MeshletSize> *thisptr = array_thisptr<rdcarray<MeshletSize>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ResourceDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ResourceDescription",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ResourceDescription' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ResourceDescription' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  rdcarray< ResourceDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription___eq__' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription___eq__' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription___eq__' argument 2 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription___eq__' argument 2 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ResourceDescription > const *)arg1)->operator ==((rdcarray< ResourceDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  rdcarray< ResourceDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription___ne__' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription___ne__' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription___ne__' argument 2 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription___ne__' argument 2 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ResourceDescription > const *)arg1)->operator !=((rdcarray< ResourceDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  rdcarray< ResourceDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription___lt__' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription___lt__' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription___lt__' argument 2 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription___lt__' argument 2 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ResourceDescription > const *)arg1)->operator <((rdcarray< ResourceDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_resize_for_index' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_resize_for_index' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ResourceDescription_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  size_t arg2 ;
  ResourceDescription *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceDescription_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_fill' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_fill' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ResourceDescription_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ResourceDescription,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ResourceDescription_fill" "', argument " "3"" of type '" "ResourceDescription const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ResourceDescription_fill" "', argument " "3"" of type '" "ResourceDescription const &""'"); 
  }
  arg3 = reinterpret_cast< ResourceDescription * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ResourceDescription const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceDescription_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_pop_back' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_pop_back' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  SwigValueWrapper< std::function< bool (ResourceDescription const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_removeIf' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_removeIf' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ResourceDescription const &) >>("rdcarray_of_ResourceDescription_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  SwigValueWrapper< std::function< bool (ResourceDescription const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_removeOneIf' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_removeOneIf' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ResourceDescription const &) >>("rdcarray_of_ResourceDescription_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_append' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_append' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceDescription_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceDescription_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_clear' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_clear' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceDescription_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceDescription_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_insert' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_insert' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceDescription_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ResourceDescription_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_pop' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_pop' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceDescription_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ResourceDescription_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_sort' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_sort' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ResourceDescription_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceDescription_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceDescription_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_copy' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_copy' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceDescription_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceDescription_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_reverse' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_reverse' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceDescription_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ResourceDescription_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_index' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_index' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceDescription_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_count' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_count' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceDescription_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_extend' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_extend' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceDescription_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceDescription_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceDescription > *arg1 = (rdcarray< ResourceDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceDescription_remove' argument 1 of type 'rdcarray< ResourceDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceDescription_remove' argument 1 of type 'rdcarray< ResourceDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceDescription_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ResourceDescription) /* defines _wrap_delete_rdcarray_of_ResourceDescription_destructor_closure */


PyObject *repr_rdcarray_of_ResourceDescription(PyObject *self)
{
  rdcarray<ResourceDescription> *thisptr = array_thisptr<rdcarray<ResourceDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ResourceDescription(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ResourceDescription> *thisptr = array_thisptr<rdcarray<ResourceDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ResourceDescription(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ResourceDescription> *thisptr = array_thisptr<rdcarray<ResourceDescription>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ResourceDescription(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ResourceDescription> *thisptr = array_thisptr<rdcarray<ResourceDescription>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ResourceDescription(PyObject *self, PyObject *idx)
{
  rdcarray<ResourceDescription> *thisptr = array_thisptr<rdcarray<ResourceDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ResourceDescription(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ResourceDescription> *thisptr = array_thisptr<rdcarray<ResourceDescription>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ResourceDescription(PyObject *self, PyObject *vals)
{
  rdcarray<ResourceDescription> *thisptr = array_thisptr<rdcarray<ResourceDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ResourceDescription(PyObject *self, Py_ssize_t count)
{
  rdcarray<ResourceDescription> *thisptr = array_thisptr<rdcarray<ResourceDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ResourceDescription(PyObject *self, PyObject *vals)
{
  rdcarray<ResourceDescription> *thisptr = array_thisptr<rdcarray<ResourceDescription>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ResourceDescription(PyObject *self, Py_ssize_t count)
{
  rdcarray<ResourceDescription> *thisptr = array_thisptr<rdcarray<ResourceDescription>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ResourceId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ResourceId",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ResourceId' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ResourceId' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  rdcarray< ResourceId > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId___eq__' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId___eq__' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId___eq__' argument 2 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId___eq__' argument 2 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ResourceId > const *)arg1)->operator ==((rdcarray< ResourceId > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  rdcarray< ResourceId > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId___ne__' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId___ne__' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId___ne__' argument 2 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId___ne__' argument 2 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ResourceId > const *)arg1)->operator !=((rdcarray< ResourceId > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  rdcarray< ResourceId > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId___lt__' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId___lt__' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId___lt__' argument 2 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId___lt__' argument 2 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ResourceId > const *)arg1)->operator <((rdcarray< ResourceId > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_resize_for_index' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_resize_for_index' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ResourceId_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  size_t arg2 ;
  ResourceId *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceId_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_fill' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_fill' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ResourceId_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ResourceId,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ResourceId_fill" "', argument " "3"" of type '" "ResourceId const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ResourceId_fill" "', argument " "3"" of type '" "ResourceId const &""'"); 
  }
  arg3 = reinterpret_cast< ResourceId * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ResourceId const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceId_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_pop_back' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_pop_back' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  SwigValueWrapper< std::function< bool (ResourceId const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_removeIf' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_removeIf' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ResourceId const &) >>("rdcarray_of_ResourceId_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  SwigValueWrapper< std::function< bool (ResourceId const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_removeOneIf' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_removeOneIf' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ResourceId const &) >>("rdcarray_of_ResourceId_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_append' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_append' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceId_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceId_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_clear' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_clear' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceId_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceId_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_insert' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_insert' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceId_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ResourceId_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_pop' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_pop' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceId_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ResourceId_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_sort' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_sort' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ResourceId_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceId_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceId_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_copy' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_copy' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceId_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceId_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_reverse' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_reverse' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceId_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ResourceId_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_index' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_index' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceId_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_count' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_count' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceId_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_extend' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_extend' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceId_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceId_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceId > *arg1 = (rdcarray< ResourceId > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceId >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceId_remove' argument 1 of type 'rdcarray< ResourceId >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceId_remove' argument 1 of type 'rdcarray< ResourceId >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceId_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ResourceId) /* defines _wrap_delete_rdcarray_of_ResourceId_destructor_closure */


PyObject *repr_rdcarray_of_ResourceId(PyObject *self)
{
  rdcarray<ResourceId> *thisptr = array_thisptr<rdcarray<ResourceId>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ResourceId(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ResourceId> *thisptr = array_thisptr<rdcarray<ResourceId>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ResourceId(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ResourceId> *thisptr = array_thisptr<rdcarray<ResourceId>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ResourceId(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ResourceId> *thisptr = array_thisptr<rdcarray<ResourceId>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ResourceId(PyObject *self, PyObject *idx)
{
  rdcarray<ResourceId> *thisptr = array_thisptr<rdcarray<ResourceId>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ResourceId(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ResourceId> *thisptr = array_thisptr<rdcarray<ResourceId>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ResourceId(PyObject *self, PyObject *vals)
{
  rdcarray<ResourceId> *thisptr = array_thisptr<rdcarray<ResourceId>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ResourceId(PyObject *self, Py_ssize_t count)
{
  rdcarray<ResourceId> *thisptr = array_thisptr<rdcarray<ResourceId>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ResourceId(PyObject *self, PyObject *vals)
{
  rdcarray<ResourceId> *thisptr = array_thisptr<rdcarray<ResourceId>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ResourceId(PyObject *self, Py_ssize_t count)
{
  rdcarray<ResourceId> *thisptr = array_thisptr<rdcarray<ResourceId>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_LineColumnInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_LineColumnInfo",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_LineColumnInfo' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_LineColumnInfo' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  rdcarray< LineColumnInfo > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo___eq__' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo___eq__' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo___eq__' argument 2 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo___eq__' argument 2 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< LineColumnInfo > const *)arg1)->operator ==((rdcarray< LineColumnInfo > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  rdcarray< LineColumnInfo > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo___ne__' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo___ne__' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo___ne__' argument 2 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo___ne__' argument 2 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< LineColumnInfo > const *)arg1)->operator !=((rdcarray< LineColumnInfo > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  rdcarray< LineColumnInfo > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo___lt__' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo___lt__' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo___lt__' argument 2 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo___lt__' argument 2 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< LineColumnInfo > const *)arg1)->operator <((rdcarray< LineColumnInfo > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_resize_for_index' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_resize_for_index' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_LineColumnInfo_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  size_t arg2 ;
  LineColumnInfo *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_LineColumnInfo_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_fill' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_fill' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_LineColumnInfo_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_LineColumnInfo,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_LineColumnInfo_fill" "', argument " "3"" of type '" "LineColumnInfo const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_LineColumnInfo_fill" "', argument " "3"" of type '" "LineColumnInfo const &""'"); 
  }
  arg3 = reinterpret_cast< LineColumnInfo * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(LineColumnInfo const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_LineColumnInfo_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_pop_back' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_pop_back' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  SwigValueWrapper< std::function< bool (LineColumnInfo const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_removeIf' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_removeIf' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (LineColumnInfo const &) >>("rdcarray_of_LineColumnInfo_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  SwigValueWrapper< std::function< bool (LineColumnInfo const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_removeOneIf' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_removeOneIf' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (LineColumnInfo const &) >>("rdcarray_of_LineColumnInfo_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_append' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_append' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_LineColumnInfo_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_LineColumnInfo_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_clear' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_clear' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_LineColumnInfo_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_LineColumnInfo_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_insert' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_insert' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_LineColumnInfo_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_LineColumnInfo_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_pop' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_pop' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_LineColumnInfo_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_LineColumnInfo_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_sort' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_sort' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_LineColumnInfo_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_LineColumnInfo_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_LineColumnInfo_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_copy' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_copy' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_LineColumnInfo_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_LineColumnInfo_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_reverse' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_reverse' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_LineColumnInfo_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_LineColumnInfo_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_index' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_index' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_LineColumnInfo_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_count' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_count' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_LineColumnInfo_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_extend' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_extend' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_LineColumnInfo_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_LineColumnInfo_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< LineColumnInfo > *arg1 = (rdcarray< LineColumnInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< LineColumnInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_LineColumnInfo_remove' argument 1 of type 'rdcarray< LineColumnInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_LineColumnInfo_remove' argument 1 of type 'rdcarray< LineColumnInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_LineColumnInfo_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_LineColumnInfo) /* defines _wrap_delete_rdcarray_of_LineColumnInfo_destructor_closure */


PyObject *repr_rdcarray_of_LineColumnInfo(PyObject *self)
{
  rdcarray<LineColumnInfo> *thisptr = array_thisptr<rdcarray<LineColumnInfo>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_LineColumnInfo(PyObject *self, Py_ssize_t idx)
{
  rdcarray<LineColumnInfo> *thisptr = array_thisptr<rdcarray<LineColumnInfo>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_LineColumnInfo(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<LineColumnInfo> *thisptr = array_thisptr<rdcarray<LineColumnInfo>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_LineColumnInfo(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<LineColumnInfo> *thisptr = array_thisptr<rdcarray<LineColumnInfo>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_LineColumnInfo(PyObject *self, PyObject *idx)
{
  rdcarray<LineColumnInfo> *thisptr = array_thisptr<rdcarray<LineColumnInfo>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_LineColumnInfo(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<LineColumnInfo> *thisptr = array_thisptr<rdcarray<LineColumnInfo>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_LineColumnInfo(PyObject *self, PyObject *vals)
{
  rdcarray<LineColumnInfo> *thisptr = array_thisptr<rdcarray<LineColumnInfo>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_LineColumnInfo(PyObject *self, Py_ssize_t count)
{
  rdcarray<LineColumnInfo> *thisptr = array_thisptr<rdcarray<LineColumnInfo>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_LineColumnInfo(PyObject *self, PyObject *vals)
{
  rdcarray<LineColumnInfo> *thisptr = array_thisptr<rdcarray<LineColumnInfo>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_LineColumnInfo(PyObject *self, Py_ssize_t count)
{
  rdcarray<LineColumnInfo> *thisptr = array_thisptr<rdcarray<LineColumnInfo>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_InstructionSourceInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_InstructionSourceInfo",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_InstructionSourceInfo' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_InstructionSourceInfo' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  rdcarray< InstructionSourceInfo > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo___eq__' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo___eq__' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo___eq__' argument 2 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo___eq__' argument 2 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< InstructionSourceInfo > const *)arg1)->operator ==((rdcarray< InstructionSourceInfo > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  rdcarray< InstructionSourceInfo > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo___ne__' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo___ne__' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo___ne__' argument 2 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo___ne__' argument 2 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< InstructionSourceInfo > const *)arg1)->operator !=((rdcarray< InstructionSourceInfo > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  rdcarray< InstructionSourceInfo > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo___lt__' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo___lt__' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo___lt__' argument 2 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo___lt__' argument 2 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< InstructionSourceInfo > const *)arg1)->operator <((rdcarray< InstructionSourceInfo > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_resize_for_index' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_resize_for_index' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_InstructionSourceInfo_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  size_t arg2 ;
  InstructionSourceInfo *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_InstructionSourceInfo_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_fill' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_fill' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_InstructionSourceInfo_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_InstructionSourceInfo,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_InstructionSourceInfo_fill" "', argument " "3"" of type '" "InstructionSourceInfo const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_InstructionSourceInfo_fill" "', argument " "3"" of type '" "InstructionSourceInfo const &""'"); 
  }
  arg3 = reinterpret_cast< InstructionSourceInfo * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(InstructionSourceInfo const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_InstructionSourceInfo_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_pop_back' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_pop_back' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  SwigValueWrapper< std::function< bool (InstructionSourceInfo const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_removeIf' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_removeIf' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (InstructionSourceInfo const &) >>("rdcarray_of_InstructionSourceInfo_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  SwigValueWrapper< std::function< bool (InstructionSourceInfo const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_removeOneIf' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_removeOneIf' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (InstructionSourceInfo const &) >>("rdcarray_of_InstructionSourceInfo_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_append' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_append' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_InstructionSourceInfo_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_InstructionSourceInfo_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_clear' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_clear' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_InstructionSourceInfo_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_InstructionSourceInfo_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_insert' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_insert' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_InstructionSourceInfo_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_InstructionSourceInfo_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_pop' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_pop' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_InstructionSourceInfo_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_InstructionSourceInfo_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_sort' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_sort' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_InstructionSourceInfo_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_InstructionSourceInfo_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_InstructionSourceInfo_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_copy' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_copy' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_InstructionSourceInfo_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_InstructionSourceInfo_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_reverse' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_reverse' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_InstructionSourceInfo_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_InstructionSourceInfo_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_index' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_index' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_InstructionSourceInfo_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_count' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_count' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_InstructionSourceInfo_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_extend' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_extend' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_InstructionSourceInfo_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_InstructionSourceInfo_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< InstructionSourceInfo > *arg1 = (rdcarray< InstructionSourceInfo > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< InstructionSourceInfo >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_InstructionSourceInfo_remove' argument 1 of type 'rdcarray< InstructionSourceInfo >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_InstructionSourceInfo_remove' argument 1 of type 'rdcarray< InstructionSourceInfo >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_InstructionSourceInfo_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_InstructionSourceInfo) /* defines _wrap_delete_rdcarray_of_InstructionSourceInfo_destructor_closure */


PyObject *repr_rdcarray_of_InstructionSourceInfo(PyObject *self)
{
  rdcarray<InstructionSourceInfo> *thisptr = array_thisptr<rdcarray<InstructionSourceInfo>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_InstructionSourceInfo(PyObject *self, Py_ssize_t idx)
{
  rdcarray<InstructionSourceInfo> *thisptr = array_thisptr<rdcarray<InstructionSourceInfo>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_InstructionSourceInfo(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<InstructionSourceInfo> *thisptr = array_thisptr<rdcarray<InstructionSourceInfo>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_InstructionSourceInfo(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<InstructionSourceInfo> *thisptr = array_thisptr<rdcarray<InstructionSourceInfo>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_InstructionSourceInfo(PyObject *self, PyObject *idx)
{
  rdcarray<InstructionSourceInfo> *thisptr = array_thisptr<rdcarray<InstructionSourceInfo>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_InstructionSourceInfo(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<InstructionSourceInfo> *thisptr = array_thisptr<rdcarray<InstructionSourceInfo>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_InstructionSourceInfo(PyObject *self, PyObject *vals)
{
  rdcarray<InstructionSourceInfo> *thisptr = array_thisptr<rdcarray<InstructionSourceInfo>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_InstructionSourceInfo(PyObject *self, Py_ssize_t count)
{
  rdcarray<InstructionSourceInfo> *thisptr = array_thisptr<rdcarray<InstructionSourceInfo>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_InstructionSourceInfo(PyObject *self, PyObject *vals)
{
  rdcarray<InstructionSourceInfo> *thisptr = array_thisptr<rdcarray<InstructionSourceInfo>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_InstructionSourceInfo(PyObject *self, Py_ssize_t count)
{
  rdcarray<InstructionSourceInfo> *thisptr = array_thisptr<rdcarray<InstructionSourceInfo>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderCompileFlag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderCompileFlag",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderCompileFlag' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderCompileFlag' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  rdcarray< ShaderCompileFlag > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag___eq__' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag___eq__' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag___eq__' argument 2 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag___eq__' argument 2 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderCompileFlag > const *)arg1)->operator ==((rdcarray< ShaderCompileFlag > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  rdcarray< ShaderCompileFlag > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag___ne__' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag___ne__' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag___ne__' argument 2 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag___ne__' argument 2 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderCompileFlag > const *)arg1)->operator !=((rdcarray< ShaderCompileFlag > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  rdcarray< ShaderCompileFlag > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag___lt__' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag___lt__' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag___lt__' argument 2 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag___lt__' argument 2 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderCompileFlag > const *)arg1)->operator <((rdcarray< ShaderCompileFlag > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_resize_for_index' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_resize_for_index' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderCompileFlag_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  size_t arg2 ;
  ShaderCompileFlag *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderCompileFlag_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_fill' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_fill' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderCompileFlag_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ShaderCompileFlag,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ShaderCompileFlag_fill" "', argument " "3"" of type '" "ShaderCompileFlag const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ShaderCompileFlag_fill" "', argument " "3"" of type '" "ShaderCompileFlag const &""'"); 
  }
  arg3 = reinterpret_cast< ShaderCompileFlag * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderCompileFlag const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderCompileFlag_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_pop_back' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_pop_back' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderCompileFlag const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_removeIf' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_removeIf' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderCompileFlag const &) >>("rdcarray_of_ShaderCompileFlag_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderCompileFlag const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_removeOneIf' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_removeOneIf' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderCompileFlag const &) >>("rdcarray_of_ShaderCompileFlag_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_append' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_append' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderCompileFlag_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderCompileFlag_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_clear' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_clear' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderCompileFlag_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderCompileFlag_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_insert' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_insert' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderCompileFlag_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderCompileFlag_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_pop' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_pop' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderCompileFlag_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderCompileFlag_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_sort' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_sort' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderCompileFlag_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderCompileFlag_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderCompileFlag_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_copy' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_copy' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderCompileFlag_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderCompileFlag_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_reverse' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_reverse' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderCompileFlag_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderCompileFlag_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_index' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_index' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderCompileFlag_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_count' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_count' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderCompileFlag_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_extend' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_extend' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderCompileFlag_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderCompileFlag_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderCompileFlag > *arg1 = (rdcarray< ShaderCompileFlag > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderCompileFlag >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderCompileFlag_remove' argument 1 of type 'rdcarray< ShaderCompileFlag >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderCompileFlag_remove' argument 1 of type 'rdcarray< ShaderCompileFlag >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderCompileFlag_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderCompileFlag) /* defines _wrap_delete_rdcarray_of_ShaderCompileFlag_destructor_closure */


PyObject *repr_rdcarray_of_ShaderCompileFlag(PyObject *self)
{
  rdcarray<ShaderCompileFlag> *thisptr = array_thisptr<rdcarray<ShaderCompileFlag>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderCompileFlag(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderCompileFlag> *thisptr = array_thisptr<rdcarray<ShaderCompileFlag>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderCompileFlag(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderCompileFlag> *thisptr = array_thisptr<rdcarray<ShaderCompileFlag>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderCompileFlag(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderCompileFlag> *thisptr = array_thisptr<rdcarray<ShaderCompileFlag>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderCompileFlag(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderCompileFlag> *thisptr = array_thisptr<rdcarray<ShaderCompileFlag>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderCompileFlag(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderCompileFlag> *thisptr = array_thisptr<rdcarray<ShaderCompileFlag>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderCompileFlag(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderCompileFlag> *thisptr = array_thisptr<rdcarray<ShaderCompileFlag>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderCompileFlag(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderCompileFlag> *thisptr = array_thisptr<rdcarray<ShaderCompileFlag>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderCompileFlag(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderCompileFlag> *thisptr = array_thisptr<rdcarray<ShaderCompileFlag>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderCompileFlag(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderCompileFlag> *thisptr = array_thisptr<rdcarray<ShaderCompileFlag>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderConstant(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderConstant",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderConstant' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderConstant' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  rdcarray< ShaderConstant > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant___eq__' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant___eq__' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant___eq__' argument 2 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant___eq__' argument 2 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderConstant > const *)arg1)->operator ==((rdcarray< ShaderConstant > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  rdcarray< ShaderConstant > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant___ne__' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant___ne__' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant___ne__' argument 2 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant___ne__' argument 2 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderConstant > const *)arg1)->operator !=((rdcarray< ShaderConstant > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  rdcarray< ShaderConstant > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant___lt__' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant___lt__' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant___lt__' argument 2 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant___lt__' argument 2 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderConstant > const *)arg1)->operator <((rdcarray< ShaderConstant > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_resize_for_index' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_resize_for_index' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderConstant_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  size_t arg2 ;
  ShaderConstant *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderConstant_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_fill' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_fill' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderConstant_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ShaderConstant,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ShaderConstant_fill" "', argument " "3"" of type '" "ShaderConstant const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ShaderConstant_fill" "', argument " "3"" of type '" "ShaderConstant const &""'"); 
  }
  arg3 = reinterpret_cast< ShaderConstant * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderConstant const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderConstant_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_pop_back' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_pop_back' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderConstant const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_removeIf' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_removeIf' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderConstant const &) >>("rdcarray_of_ShaderConstant_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderConstant const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_removeOneIf' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_removeOneIf' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderConstant const &) >>("rdcarray_of_ShaderConstant_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_append' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_append' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstant_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderConstant_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_clear' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_clear' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstant_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderConstant_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_insert' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_insert' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstant_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderConstant_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_pop' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_pop' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstant_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderConstant_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_sort' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_sort' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderConstant_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstant_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderConstant_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_copy' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_copy' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstant_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderConstant_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_reverse' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_reverse' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstant_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderConstant_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_index' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_index' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstant_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_count' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_count' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstant_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_extend' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_extend' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstant_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstant_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstant > *arg1 = (rdcarray< ShaderConstant > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstant >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstant_remove' argument 1 of type 'rdcarray< ShaderConstant >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstant_remove' argument 1 of type 'rdcarray< ShaderConstant >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstant_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderConstant) /* defines _wrap_delete_rdcarray_of_ShaderConstant_destructor_closure */


PyObject *repr_rdcarray_of_ShaderConstant(PyObject *self)
{
  rdcarray<ShaderConstant> *thisptr = array_thisptr<rdcarray<ShaderConstant>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderConstant(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderConstant> *thisptr = array_thisptr<rdcarray<ShaderConstant>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderConstant(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderConstant> *thisptr = array_thisptr<rdcarray<ShaderConstant>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderConstant(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderConstant> *thisptr = array_thisptr<rdcarray<ShaderConstant>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderConstant(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderConstant> *thisptr = array_thisptr<rdcarray<ShaderConstant>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderConstant(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderConstant> *thisptr = array_thisptr<rdcarray<ShaderConstant>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderConstant(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderConstant> *thisptr = array_thisptr<rdcarray<ShaderConstant>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderConstant(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderConstant> *thisptr = array_thisptr<rdcarray<ShaderConstant>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderConstant(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderConstant> *thisptr = array_thisptr<rdcarray<ShaderConstant>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderConstant(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderConstant> *thisptr = array_thisptr<rdcarray<ShaderConstant>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderDebugState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderDebugState",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderDebugState' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderDebugState' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  rdcarray< ShaderDebugState > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState___eq__' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState___eq__' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState___eq__' argument 2 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState___eq__' argument 2 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderDebugState > const *)arg1)->operator ==((rdcarray< ShaderDebugState > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  rdcarray< ShaderDebugState > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState___ne__' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState___ne__' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState___ne__' argument 2 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState___ne__' argument 2 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderDebugState > const *)arg1)->operator !=((rdcarray< ShaderDebugState > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  rdcarray< ShaderDebugState > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState___lt__' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState___lt__' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState___lt__' argument 2 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState___lt__' argument 2 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderDebugState > const *)arg1)->operator <((rdcarray< ShaderDebugState > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_resize_for_index' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_resize_for_index' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderDebugState_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  size_t arg2 ;
  ShaderDebugState *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderDebugState_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_fill' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_fill' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderDebugState_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ShaderDebugState,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ShaderDebugState_fill" "', argument " "3"" of type '" "ShaderDebugState const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ShaderDebugState_fill" "', argument " "3"" of type '" "ShaderDebugState const &""'"); 
  }
  arg3 = reinterpret_cast< ShaderDebugState * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderDebugState const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderDebugState_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_pop_back' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_pop_back' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderDebugState const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_removeIf' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_removeIf' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderDebugState const &) >>("rdcarray_of_ShaderDebugState_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderDebugState const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_removeOneIf' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_removeOneIf' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderDebugState const &) >>("rdcarray_of_ShaderDebugState_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_append' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_append' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderDebugState_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderDebugState_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_clear' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_clear' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderDebugState_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderDebugState_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_insert' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_insert' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderDebugState_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderDebugState_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_pop' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_pop' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderDebugState_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderDebugState_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_sort' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_sort' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderDebugState_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderDebugState_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderDebugState_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_copy' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_copy' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderDebugState_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderDebugState_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_reverse' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_reverse' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderDebugState_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderDebugState_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_index' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_index' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderDebugState_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_count' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_count' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderDebugState_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_extend' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_extend' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderDebugState_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderDebugState_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderDebugState > *arg1 = (rdcarray< ShaderDebugState > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderDebugState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderDebugState_remove' argument 1 of type 'rdcarray< ShaderDebugState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderDebugState_remove' argument 1 of type 'rdcarray< ShaderDebugState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderDebugState_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderDebugState) /* defines _wrap_delete_rdcarray_of_ShaderDebugState_destructor_closure */


PyObject *repr_rdcarray_of_ShaderDebugState(PyObject *self)
{
  rdcarray<ShaderDebugState> *thisptr = array_thisptr<rdcarray<ShaderDebugState>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderDebugState(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderDebugState> *thisptr = array_thisptr<rdcarray<ShaderDebugState>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderDebugState(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderDebugState> *thisptr = array_thisptr<rdcarray<ShaderDebugState>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderDebugState(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderDebugState> *thisptr = array_thisptr<rdcarray<ShaderDebugState>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderDebugState(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderDebugState> *thisptr = array_thisptr<rdcarray<ShaderDebugState>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderDebugState(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderDebugState> *thisptr = array_thisptr<rdcarray<ShaderDebugState>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderDebugState(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderDebugState> *thisptr = array_thisptr<rdcarray<ShaderDebugState>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderDebugState(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderDebugState> *thisptr = array_thisptr<rdcarray<ShaderDebugState>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderDebugState(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderDebugState> *thisptr = array_thisptr<rdcarray<ShaderDebugState>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderDebugState(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderDebugState> *thisptr = array_thisptr<rdcarray<ShaderDebugState>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderMessage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderMessage",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderMessage' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderMessage' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  rdcarray< ShaderMessage > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage___eq__' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage___eq__' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage___eq__' argument 2 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage___eq__' argument 2 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderMessage > const *)arg1)->operator ==((rdcarray< ShaderMessage > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  rdcarray< ShaderMessage > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage___ne__' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage___ne__' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage___ne__' argument 2 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage___ne__' argument 2 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderMessage > const *)arg1)->operator !=((rdcarray< ShaderMessage > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  rdcarray< ShaderMessage > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage___lt__' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage___lt__' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage___lt__' argument 2 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage___lt__' argument 2 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderMessage > const *)arg1)->operator <((rdcarray< ShaderMessage > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_resize_for_index' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_resize_for_index' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderMessage_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  size_t arg2 ;
  ShaderMessage *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderMessage_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_fill' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_fill' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderMessage_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ShaderMessage,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ShaderMessage_fill" "', argument " "3"" of type '" "ShaderMessage const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ShaderMessage_fill" "', argument " "3"" of type '" "ShaderMessage const &""'"); 
  }
  arg3 = reinterpret_cast< ShaderMessage * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderMessage const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderMessage_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_pop_back' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_pop_back' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderMessage const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_removeIf' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_removeIf' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderMessage const &) >>("rdcarray_of_ShaderMessage_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderMessage const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_removeOneIf' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_removeOneIf' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderMessage const &) >>("rdcarray_of_ShaderMessage_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_append' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_append' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderMessage_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderMessage_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_clear' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_clear' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderMessage_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderMessage_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_insert' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_insert' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderMessage_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderMessage_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_pop' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_pop' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderMessage_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderMessage_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_sort' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_sort' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderMessage_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderMessage_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderMessage_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_copy' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_copy' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderMessage_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderMessage_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_reverse' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_reverse' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderMessage_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderMessage_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_index' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_index' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderMessage_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_count' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_count' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderMessage_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_extend' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_extend' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderMessage_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderMessage_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderMessage > *arg1 = (rdcarray< ShaderMessage > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderMessage >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderMessage_remove' argument 1 of type 'rdcarray< ShaderMessage >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderMessage_remove' argument 1 of type 'rdcarray< ShaderMessage >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderMessage_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderMessage) /* defines _wrap_delete_rdcarray_of_ShaderMessage_destructor_closure */


PyObject *repr_rdcarray_of_ShaderMessage(PyObject *self)
{
  rdcarray<ShaderMessage> *thisptr = array_thisptr<rdcarray<ShaderMessage>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderMessage(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderMessage> *thisptr = array_thisptr<rdcarray<ShaderMessage>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderMessage(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderMessage> *thisptr = array_thisptr<rdcarray<ShaderMessage>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderMessage(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderMessage> *thisptr = array_thisptr<rdcarray<ShaderMessage>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderMessage(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderMessage> *thisptr = array_thisptr<rdcarray<ShaderMessage>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderMessage(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderMessage> *thisptr = array_thisptr<rdcarray<ShaderMessage>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderMessage(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderMessage> *thisptr = array_thisptr<rdcarray<ShaderMessage>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderMessage(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderMessage> *thisptr = array_thisptr<rdcarray<ShaderMessage>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderMessage(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderMessage> *thisptr = array_thisptr<rdcarray<ShaderMessage>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderMessage(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderMessage> *thisptr = array_thisptr<rdcarray<ShaderMessage>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderResource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderResource",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderResource' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderResource' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  rdcarray< ShaderResource > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource___eq__' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource___eq__' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource___eq__' argument 2 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource___eq__' argument 2 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderResource > const *)arg1)->operator ==((rdcarray< ShaderResource > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  rdcarray< ShaderResource > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource___ne__' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource___ne__' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource___ne__' argument 2 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource___ne__' argument 2 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderResource > const *)arg1)->operator !=((rdcarray< ShaderResource > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  rdcarray< ShaderResource > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource___lt__' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource___lt__' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource___lt__' argument 2 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource___lt__' argument 2 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderResource > const *)arg1)->operator <((rdcarray< ShaderResource > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_resize_for_index' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_resize_for_index' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderResource_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  size_t arg2 ;
  ShaderResource *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderResource_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_fill' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_fill' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderResource_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ShaderResource,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ShaderResource_fill" "', argument " "3"" of type '" "ShaderResource const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ShaderResource_fill" "', argument " "3"" of type '" "ShaderResource const &""'"); 
  }
  arg3 = reinterpret_cast< ShaderResource * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderResource const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderResource_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_pop_back' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_pop_back' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderResource const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_removeIf' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_removeIf' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderResource const &) >>("rdcarray_of_ShaderResource_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderResource const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_removeOneIf' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_removeOneIf' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderResource const &) >>("rdcarray_of_ShaderResource_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_append' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_append' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderResource_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderResource_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_clear' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_clear' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderResource_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderResource_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_insert' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_insert' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderResource_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderResource_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_pop' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_pop' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderResource_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderResource_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_sort' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_sort' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderResource_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderResource_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderResource_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_copy' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_copy' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderResource_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderResource_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_reverse' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_reverse' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderResource_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderResource_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_index' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_index' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderResource_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_count' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_count' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderResource_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_extend' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_extend' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderResource_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderResource_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderResource > *arg1 = (rdcarray< ShaderResource > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderResource >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderResource_remove' argument 1 of type 'rdcarray< ShaderResource >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderResource_remove' argument 1 of type 'rdcarray< ShaderResource >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderResource_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderResource) /* defines _wrap_delete_rdcarray_of_ShaderResource_destructor_closure */


PyObject *repr_rdcarray_of_ShaderResource(PyObject *self)
{
  rdcarray<ShaderResource> *thisptr = array_thisptr<rdcarray<ShaderResource>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderResource(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderResource> *thisptr = array_thisptr<rdcarray<ShaderResource>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderResource(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderResource> *thisptr = array_thisptr<rdcarray<ShaderResource>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderResource(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderResource> *thisptr = array_thisptr<rdcarray<ShaderResource>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderResource(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderResource> *thisptr = array_thisptr<rdcarray<ShaderResource>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderResource(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderResource> *thisptr = array_thisptr<rdcarray<ShaderResource>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderResource(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderResource> *thisptr = array_thisptr<rdcarray<ShaderResource>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderResource(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderResource> *thisptr = array_thisptr<rdcarray<ShaderResource>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderResource(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderResource> *thisptr = array_thisptr<rdcarray<ShaderResource>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderResource(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderResource> *thisptr = array_thisptr<rdcarray<ShaderResource>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderSampler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderSampler",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderSampler' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderSampler' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  rdcarray< ShaderSampler > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler___eq__' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler___eq__' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler___eq__' argument 2 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler___eq__' argument 2 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderSampler > const *)arg1)->operator ==((rdcarray< ShaderSampler > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  rdcarray< ShaderSampler > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler___ne__' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler___ne__' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler___ne__' argument 2 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler___ne__' argument 2 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderSampler > const *)arg1)->operator !=((rdcarray< ShaderSampler > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  rdcarray< ShaderSampler > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler___lt__' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler___lt__' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler___lt__' argument 2 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler___lt__' argument 2 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderSampler > const *)arg1)->operator <((rdcarray< ShaderSampler > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_resize_for_index' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_resize_for_index' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderSampler_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  size_t arg2 ;
  ShaderSampler *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSampler_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_fill' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_fill' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderSampler_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ShaderSampler,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ShaderSampler_fill" "', argument " "3"" of type '" "ShaderSampler const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ShaderSampler_fill" "', argument " "3"" of type '" "ShaderSampler const &""'"); 
  }
  arg3 = reinterpret_cast< ShaderSampler * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderSampler const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSampler_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_pop_back' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_pop_back' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderSampler const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_removeIf' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_removeIf' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderSampler const &) >>("rdcarray_of_ShaderSampler_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderSampler const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_removeOneIf' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_removeOneIf' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderSampler const &) >>("rdcarray_of_ShaderSampler_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_append' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_append' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSampler_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSampler_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_clear' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_clear' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSampler_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSampler_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_insert' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_insert' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSampler_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderSampler_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_pop' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_pop' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSampler_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderSampler_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_sort' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_sort' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderSampler_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSampler_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSampler_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_copy' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_copy' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSampler_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSampler_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_reverse' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_reverse' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSampler_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderSampler_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_index' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_index' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSampler_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_count' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_count' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSampler_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_extend' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_extend' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSampler_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSampler_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSampler > *arg1 = (rdcarray< ShaderSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSampler_remove' argument 1 of type 'rdcarray< ShaderSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSampler_remove' argument 1 of type 'rdcarray< ShaderSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSampler_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderSampler) /* defines _wrap_delete_rdcarray_of_ShaderSampler_destructor_closure */


PyObject *repr_rdcarray_of_ShaderSampler(PyObject *self)
{
  rdcarray<ShaderSampler> *thisptr = array_thisptr<rdcarray<ShaderSampler>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderSampler(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderSampler> *thisptr = array_thisptr<rdcarray<ShaderSampler>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderSampler(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderSampler> *thisptr = array_thisptr<rdcarray<ShaderSampler>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderSampler(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderSampler> *thisptr = array_thisptr<rdcarray<ShaderSampler>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderSampler(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderSampler> *thisptr = array_thisptr<rdcarray<ShaderSampler>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderSampler(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderSampler> *thisptr = array_thisptr<rdcarray<ShaderSampler>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderSampler(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderSampler> *thisptr = array_thisptr<rdcarray<ShaderSampler>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderSampler(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderSampler> *thisptr = array_thisptr<rdcarray<ShaderSampler>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderSampler(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderSampler> *thisptr = array_thisptr<rdcarray<ShaderSampler>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderSampler(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderSampler> *thisptr = array_thisptr<rdcarray<ShaderSampler>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderSourceFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderSourceFile",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderSourceFile' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderSourceFile' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  rdcarray< ShaderSourceFile > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile___eq__' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile___eq__' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile___eq__' argument 2 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile___eq__' argument 2 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderSourceFile > const *)arg1)->operator ==((rdcarray< ShaderSourceFile > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  rdcarray< ShaderSourceFile > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile___ne__' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile___ne__' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile___ne__' argument 2 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile___ne__' argument 2 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderSourceFile > const *)arg1)->operator !=((rdcarray< ShaderSourceFile > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  rdcarray< ShaderSourceFile > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile___lt__' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile___lt__' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile___lt__' argument 2 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile___lt__' argument 2 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderSourceFile > const *)arg1)->operator <((rdcarray< ShaderSourceFile > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_resize_for_index' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_resize_for_index' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderSourceFile_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  size_t arg2 ;
  ShaderSourceFile *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSourceFile_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_fill' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_fill' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderSourceFile_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ShaderSourceFile,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ShaderSourceFile_fill" "', argument " "3"" of type '" "ShaderSourceFile const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ShaderSourceFile_fill" "', argument " "3"" of type '" "ShaderSourceFile const &""'"); 
  }
  arg3 = reinterpret_cast< ShaderSourceFile * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderSourceFile const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSourceFile_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_pop_back' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_pop_back' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderSourceFile const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_removeIf' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_removeIf' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderSourceFile const &) >>("rdcarray_of_ShaderSourceFile_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderSourceFile const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_removeOneIf' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_removeOneIf' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderSourceFile const &) >>("rdcarray_of_ShaderSourceFile_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_append' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_append' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourceFile_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSourceFile_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_clear' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_clear' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourceFile_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSourceFile_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_insert' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_insert' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourceFile_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderSourceFile_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_pop' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_pop' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourceFile_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderSourceFile_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_sort' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_sort' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderSourceFile_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourceFile_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSourceFile_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_copy' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_copy' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourceFile_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSourceFile_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_reverse' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_reverse' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourceFile_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderSourceFile_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_index' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_index' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourceFile_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_count' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_count' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourceFile_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_extend' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_extend' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourceFile_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourceFile_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourceFile > *arg1 = (rdcarray< ShaderSourceFile > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourceFile >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourceFile_remove' argument 1 of type 'rdcarray< ShaderSourceFile >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourceFile_remove' argument 1 of type 'rdcarray< ShaderSourceFile >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourceFile_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderSourceFile) /* defines _wrap_delete_rdcarray_of_ShaderSourceFile_destructor_closure */


PyObject *repr_rdcarray_of_ShaderSourceFile(PyObject *self)
{
  rdcarray<ShaderSourceFile> *thisptr = array_thisptr<rdcarray<ShaderSourceFile>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderSourceFile(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderSourceFile> *thisptr = array_thisptr<rdcarray<ShaderSourceFile>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderSourceFile(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderSourceFile> *thisptr = array_thisptr<rdcarray<ShaderSourceFile>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderSourceFile(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderSourceFile> *thisptr = array_thisptr<rdcarray<ShaderSourceFile>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderSourceFile(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderSourceFile> *thisptr = array_thisptr<rdcarray<ShaderSourceFile>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderSourceFile(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderSourceFile> *thisptr = array_thisptr<rdcarray<ShaderSourceFile>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderSourceFile(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderSourceFile> *thisptr = array_thisptr<rdcarray<ShaderSourceFile>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderSourceFile(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderSourceFile> *thisptr = array_thisptr<rdcarray<ShaderSourceFile>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderSourceFile(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderSourceFile> *thisptr = array_thisptr<rdcarray<ShaderSourceFile>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderSourceFile(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderSourceFile> *thisptr = array_thisptr<rdcarray<ShaderSourceFile>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderSourcePrefix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderSourcePrefix",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderSourcePrefix' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderSourcePrefix' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  rdcarray< ShaderSourcePrefix > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix___eq__' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix___eq__' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix___eq__' argument 2 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix___eq__' argument 2 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderSourcePrefix > const *)arg1)->operator ==((rdcarray< ShaderSourcePrefix > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  rdcarray< ShaderSourcePrefix > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix___ne__' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix___ne__' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix___ne__' argument 2 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix___ne__' argument 2 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderSourcePrefix > const *)arg1)->operator !=((rdcarray< ShaderSourcePrefix > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  rdcarray< ShaderSourcePrefix > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix___lt__' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix___lt__' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix___lt__' argument 2 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix___lt__' argument 2 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderSourcePrefix > const *)arg1)->operator <((rdcarray< ShaderSourcePrefix > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_resize_for_index' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_resize_for_index' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderSourcePrefix_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  size_t arg2 ;
  ShaderSourcePrefix *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSourcePrefix_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_fill' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_fill' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderSourcePrefix_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ShaderSourcePrefix,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ShaderSourcePrefix_fill" "', argument " "3"" of type '" "ShaderSourcePrefix const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ShaderSourcePrefix_fill" "', argument " "3"" of type '" "ShaderSourcePrefix const &""'"); 
  }
  arg3 = reinterpret_cast< ShaderSourcePrefix * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderSourcePrefix const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSourcePrefix_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_pop_back' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_pop_back' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderSourcePrefix const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_removeIf' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_removeIf' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderSourcePrefix const &) >>("rdcarray_of_ShaderSourcePrefix_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderSourcePrefix const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_removeOneIf' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_removeOneIf' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderSourcePrefix const &) >>("rdcarray_of_ShaderSourcePrefix_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_append' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_append' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourcePrefix_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSourcePrefix_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_clear' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_clear' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourcePrefix_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSourcePrefix_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_insert' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_insert' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourcePrefix_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderSourcePrefix_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_pop' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_pop' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourcePrefix_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderSourcePrefix_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_sort' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_sort' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderSourcePrefix_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourcePrefix_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSourcePrefix_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_copy' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_copy' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourcePrefix_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderSourcePrefix_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_reverse' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_reverse' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourcePrefix_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderSourcePrefix_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_index' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_index' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourcePrefix_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_count' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_count' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourcePrefix_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_extend' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_extend' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourcePrefix_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderSourcePrefix_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderSourcePrefix > *arg1 = (rdcarray< ShaderSourcePrefix > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderSourcePrefix >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderSourcePrefix_remove' argument 1 of type 'rdcarray< ShaderSourcePrefix >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderSourcePrefix_remove' argument 1 of type 'rdcarray< ShaderSourcePrefix >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderSourcePrefix_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderSourcePrefix) /* defines _wrap_delete_rdcarray_of_ShaderSourcePrefix_destructor_closure */


PyObject *repr_rdcarray_of_ShaderSourcePrefix(PyObject *self)
{
  rdcarray<ShaderSourcePrefix> *thisptr = array_thisptr<rdcarray<ShaderSourcePrefix>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderSourcePrefix(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderSourcePrefix> *thisptr = array_thisptr<rdcarray<ShaderSourcePrefix>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderSourcePrefix(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderSourcePrefix> *thisptr = array_thisptr<rdcarray<ShaderSourcePrefix>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderSourcePrefix(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderSourcePrefix> *thisptr = array_thisptr<rdcarray<ShaderSourcePrefix>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderSourcePrefix(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderSourcePrefix> *thisptr = array_thisptr<rdcarray<ShaderSourcePrefix>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderSourcePrefix(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderSourcePrefix> *thisptr = array_thisptr<rdcarray<ShaderSourcePrefix>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderSourcePrefix(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderSourcePrefix> *thisptr = array_thisptr<rdcarray<ShaderSourcePrefix>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderSourcePrefix(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderSourcePrefix> *thisptr = array_thisptr<rdcarray<ShaderSourcePrefix>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderSourcePrefix(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderSourcePrefix> *thisptr = array_thisptr<rdcarray<ShaderSourcePrefix>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderSourcePrefix(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderSourcePrefix> *thisptr = array_thisptr<rdcarray<ShaderSourcePrefix>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderVariable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderVariable",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderVariable' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderVariable' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  rdcarray< ShaderVariable > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable___eq__' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable___eq__' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable___eq__' argument 2 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable___eq__' argument 2 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderVariable > const *)arg1)->operator ==((rdcarray< ShaderVariable > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  rdcarray< ShaderVariable > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable___ne__' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable___ne__' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable___ne__' argument 2 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable___ne__' argument 2 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderVariable > const *)arg1)->operator !=((rdcarray< ShaderVariable > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  rdcarray< ShaderVariable > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable___lt__' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable___lt__' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable___lt__' argument 2 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable___lt__' argument 2 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderVariable > const *)arg1)->operator <((rdcarray< ShaderVariable > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_resize_for_index' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_resize_for_index' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderVariable_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  size_t arg2 ;
  ShaderVariable *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderVariable_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_fill' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_fill' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderVariable_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ShaderVariable,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ShaderVariable_fill" "', argument " "3"" of type '" "ShaderVariable const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ShaderVariable_fill" "', argument " "3"" of type '" "ShaderVariable const &""'"); 
  }
  arg3 = reinterpret_cast< ShaderVariable * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderVariable const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderVariable_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_pop_back' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_pop_back' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderVariable const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_removeIf' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_removeIf' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderVariable const &) >>("rdcarray_of_ShaderVariable_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderVariable const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_removeOneIf' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_removeOneIf' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderVariable const &) >>("rdcarray_of_ShaderVariable_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_append' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_append' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariable_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderVariable_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_clear' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_clear' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariable_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderVariable_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_insert' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_insert' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariable_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderVariable_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_pop' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_pop' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariable_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderVariable_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_sort' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_sort' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderVariable_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariable_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderVariable_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_copy' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_copy' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariable_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderVariable_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_reverse' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_reverse' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariable_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderVariable_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_index' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_index' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariable_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_count' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_count' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariable_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_extend' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_extend' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariable_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariable_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariable > *arg1 = (rdcarray< ShaderVariable > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariable >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariable_remove' argument 1 of type 'rdcarray< ShaderVariable >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariable_remove' argument 1 of type 'rdcarray< ShaderVariable >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariable_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderVariable) /* defines _wrap_delete_rdcarray_of_ShaderVariable_destructor_closure */


PyObject *repr_rdcarray_of_ShaderVariable(PyObject *self)
{
  rdcarray<ShaderVariable> *thisptr = array_thisptr<rdcarray<ShaderVariable>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderVariable(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderVariable> *thisptr = array_thisptr<rdcarray<ShaderVariable>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderVariable(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderVariable> *thisptr = array_thisptr<rdcarray<ShaderVariable>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderVariable(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderVariable> *thisptr = array_thisptr<rdcarray<ShaderVariable>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderVariable(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderVariable> *thisptr = array_thisptr<rdcarray<ShaderVariable>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderVariable(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderVariable> *thisptr = array_thisptr<rdcarray<ShaderVariable>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderVariable(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderVariable> *thisptr = array_thisptr<rdcarray<ShaderVariable>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderVariable(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderVariable> *thisptr = array_thisptr<rdcarray<ShaderVariable>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderVariable(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderVariable> *thisptr = array_thisptr<rdcarray<ShaderVariable>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderVariable(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderVariable> *thisptr = array_thisptr<rdcarray<ShaderVariable>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderEncoding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderEncoding",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderEncoding' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderEncoding' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  rdcarray< ShaderEncoding > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding___eq__' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding___eq__' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding___eq__' argument 2 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding___eq__' argument 2 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderEncoding > const *)arg1)->operator ==((rdcarray< ShaderEncoding > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  rdcarray< ShaderEncoding > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding___ne__' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding___ne__' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding___ne__' argument 2 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding___ne__' argument 2 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderEncoding > const *)arg1)->operator !=((rdcarray< ShaderEncoding > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  rdcarray< ShaderEncoding > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding___lt__' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding___lt__' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding___lt__' argument 2 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding___lt__' argument 2 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderEncoding > const *)arg1)->operator <((rdcarray< ShaderEncoding > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_resize_for_index' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_resize_for_index' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderEncoding_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  size_t arg2 ;
  ShaderEncoding *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 ;
  ShaderEncoding temp3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderEncoding_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_fill' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_fill' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderEncoding_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int (swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderEncoding_fill" "', argument " "3"" of type '" "ShaderEncoding const &""'");
  } else {
    temp3 = static_cast< ShaderEncoding >(val3);
    arg3 = &temp3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderEncoding const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderEncoding_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_pop_back' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_pop_back' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  std::function< bool (ShaderEncoding const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_removeIf' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_removeIf' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderEncoding const &) >>("rdcarray_of_ShaderEncoding_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  std::function< bool (ShaderEncoding const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_removeOneIf' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_removeOneIf' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderEncoding const &) >>("rdcarray_of_ShaderEncoding_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_append' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_append' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEncoding_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderEncoding_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_clear' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_clear' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEncoding_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderEncoding_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_insert' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_insert' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEncoding_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderEncoding_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_pop' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_pop' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEncoding_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderEncoding_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_sort' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_sort' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderEncoding_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEncoding_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderEncoding_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_copy' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_copy' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEncoding_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderEncoding_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_reverse' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_reverse' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEncoding_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderEncoding_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_index' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_index' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEncoding_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_count' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_count' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEncoding_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_extend' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_extend' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEncoding_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEncoding_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEncoding > *arg1 = (rdcarray< ShaderEncoding > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEncoding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEncoding_remove' argument 1 of type 'rdcarray< ShaderEncoding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEncoding_remove' argument 1 of type 'rdcarray< ShaderEncoding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEncoding_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderEncoding) /* defines _wrap_delete_rdcarray_of_ShaderEncoding_destructor_closure */


PyObject *repr_rdcarray_of_ShaderEncoding(PyObject *self)
{
  rdcarray<ShaderEncoding> *thisptr = array_thisptr<rdcarray<ShaderEncoding>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderEncoding(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderEncoding> *thisptr = array_thisptr<rdcarray<ShaderEncoding>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderEncoding(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderEncoding> *thisptr = array_thisptr<rdcarray<ShaderEncoding>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderEncoding(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderEncoding> *thisptr = array_thisptr<rdcarray<ShaderEncoding>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderEncoding(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderEncoding> *thisptr = array_thisptr<rdcarray<ShaderEncoding>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderEncoding(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderEncoding> *thisptr = array_thisptr<rdcarray<ShaderEncoding>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderEncoding(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderEncoding> *thisptr = array_thisptr<rdcarray<ShaderEncoding>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderEncoding(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderEncoding> *thisptr = array_thisptr<rdcarray<ShaderEncoding>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderEncoding(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderEncoding> *thisptr = array_thisptr<rdcarray<ShaderEncoding>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderEncoding(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderEncoding> *thisptr = array_thisptr<rdcarray<ShaderEncoding>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderVariableChange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderVariableChange",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderVariableChange' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderVariableChange' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  rdcarray< ShaderVariableChange > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange___eq__' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange___eq__' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange___eq__' argument 2 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange___eq__' argument 2 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderVariableChange > const *)arg1)->operator ==((rdcarray< ShaderVariableChange > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  rdcarray< ShaderVariableChange > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange___ne__' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange___ne__' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange___ne__' argument 2 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange___ne__' argument 2 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderVariableChange > const *)arg1)->operator !=((rdcarray< ShaderVariableChange > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  rdcarray< ShaderVariableChange > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange___lt__' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange___lt__' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange___lt__' argument 2 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange___lt__' argument 2 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderVariableChange > const *)arg1)->operator <((rdcarray< ShaderVariableChange > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_resize_for_index' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_resize_for_index' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderVariableChange_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  size_t arg2 ;
  ShaderVariableChange *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderVariableChange_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_fill' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_fill' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderVariableChange_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ShaderVariableChange,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ShaderVariableChange_fill" "', argument " "3"" of type '" "ShaderVariableChange const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ShaderVariableChange_fill" "', argument " "3"" of type '" "ShaderVariableChange const &""'"); 
  }
  arg3 = reinterpret_cast< ShaderVariableChange * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderVariableChange const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderVariableChange_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_pop_back' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_pop_back' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderVariableChange const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_removeIf' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_removeIf' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderVariableChange const &) >>("rdcarray_of_ShaderVariableChange_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderVariableChange const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_removeOneIf' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_removeOneIf' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderVariableChange const &) >>("rdcarray_of_ShaderVariableChange_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_append' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_append' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariableChange_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderVariableChange_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_clear' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_clear' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariableChange_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderVariableChange_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_insert' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_insert' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariableChange_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderVariableChange_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_pop' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_pop' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariableChange_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderVariableChange_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_sort' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_sort' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderVariableChange_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariableChange_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderVariableChange_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_copy' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_copy' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariableChange_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderVariableChange_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_reverse' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_reverse' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariableChange_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderVariableChange_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_index' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_index' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariableChange_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_count' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_count' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariableChange_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_extend' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_extend' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariableChange_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderVariableChange_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderVariableChange > *arg1 = (rdcarray< ShaderVariableChange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderVariableChange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderVariableChange_remove' argument 1 of type 'rdcarray< ShaderVariableChange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderVariableChange_remove' argument 1 of type 'rdcarray< ShaderVariableChange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderVariableChange_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderVariableChange) /* defines _wrap_delete_rdcarray_of_ShaderVariableChange_destructor_closure */


PyObject *repr_rdcarray_of_ShaderVariableChange(PyObject *self)
{
  rdcarray<ShaderVariableChange> *thisptr = array_thisptr<rdcarray<ShaderVariableChange>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderVariableChange(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderVariableChange> *thisptr = array_thisptr<rdcarray<ShaderVariableChange>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderVariableChange(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderVariableChange> *thisptr = array_thisptr<rdcarray<ShaderVariableChange>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderVariableChange(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderVariableChange> *thisptr = array_thisptr<rdcarray<ShaderVariableChange>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderVariableChange(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderVariableChange> *thisptr = array_thisptr<rdcarray<ShaderVariableChange>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderVariableChange(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderVariableChange> *thisptr = array_thisptr<rdcarray<ShaderVariableChange>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderVariableChange(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderVariableChange> *thisptr = array_thisptr<rdcarray<ShaderVariableChange>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderVariableChange(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderVariableChange> *thisptr = array_thisptr<rdcarray<ShaderVariableChange>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderVariableChange(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderVariableChange> *thisptr = array_thisptr<rdcarray<ShaderVariableChange>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderVariableChange(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderVariableChange> *thisptr = array_thisptr<rdcarray<ShaderVariableChange>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_DebugVariableReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_DebugVariableReference",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_DebugVariableReference' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_DebugVariableReference' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  rdcarray< DebugVariableReference > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference___eq__' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference___eq__' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference___eq__' argument 2 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference___eq__' argument 2 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DebugVariableReference > const *)arg1)->operator ==((rdcarray< DebugVariableReference > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  rdcarray< DebugVariableReference > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference___ne__' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference___ne__' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference___ne__' argument 2 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference___ne__' argument 2 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DebugVariableReference > const *)arg1)->operator !=((rdcarray< DebugVariableReference > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  rdcarray< DebugVariableReference > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference___lt__' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference___lt__' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference___lt__' argument 2 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference___lt__' argument 2 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DebugVariableReference > const *)arg1)->operator <((rdcarray< DebugVariableReference > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_resize_for_index' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_resize_for_index' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_DebugVariableReference_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  size_t arg2 ;
  DebugVariableReference *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DebugVariableReference_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_fill' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_fill' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_DebugVariableReference_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_DebugVariableReference,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_DebugVariableReference_fill" "', argument " "3"" of type '" "DebugVariableReference const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_DebugVariableReference_fill" "', argument " "3"" of type '" "DebugVariableReference const &""'"); 
  }
  arg3 = reinterpret_cast< DebugVariableReference * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(DebugVariableReference const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DebugVariableReference_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_pop_back' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_pop_back' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  SwigValueWrapper< std::function< bool (DebugVariableReference const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_removeIf' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_removeIf' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (DebugVariableReference const &) >>("rdcarray_of_DebugVariableReference_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  SwigValueWrapper< std::function< bool (DebugVariableReference const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_removeOneIf' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_removeOneIf' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (DebugVariableReference const &) >>("rdcarray_of_DebugVariableReference_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_append' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_append' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugVariableReference_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DebugVariableReference_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_clear' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_clear' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugVariableReference_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DebugVariableReference_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_insert' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_insert' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugVariableReference_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_DebugVariableReference_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_pop' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_pop' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugVariableReference_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_DebugVariableReference_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_sort' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_sort' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_DebugVariableReference_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugVariableReference_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DebugVariableReference_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_copy' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_copy' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugVariableReference_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DebugVariableReference_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_reverse' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_reverse' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugVariableReference_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_DebugVariableReference_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_index' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_index' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugVariableReference_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_count' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_count' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugVariableReference_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_extend' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_extend' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugVariableReference_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DebugVariableReference_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DebugVariableReference > *arg1 = (rdcarray< DebugVariableReference > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DebugVariableReference >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DebugVariableReference_remove' argument 1 of type 'rdcarray< DebugVariableReference >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DebugVariableReference_remove' argument 1 of type 'rdcarray< DebugVariableReference >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DebugVariableReference_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_DebugVariableReference) /* defines _wrap_delete_rdcarray_of_DebugVariableReference_destructor_closure */


PyObject *repr_rdcarray_of_DebugVariableReference(PyObject *self)
{
  rdcarray<DebugVariableReference> *thisptr = array_thisptr<rdcarray<DebugVariableReference>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_DebugVariableReference(PyObject *self, Py_ssize_t idx)
{
  rdcarray<DebugVariableReference> *thisptr = array_thisptr<rdcarray<DebugVariableReference>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_DebugVariableReference(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<DebugVariableReference> *thisptr = array_thisptr<rdcarray<DebugVariableReference>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_DebugVariableReference(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<DebugVariableReference> *thisptr = array_thisptr<rdcarray<DebugVariableReference>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_DebugVariableReference(PyObject *self, PyObject *idx)
{
  rdcarray<DebugVariableReference> *thisptr = array_thisptr<rdcarray<DebugVariableReference>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_DebugVariableReference(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<DebugVariableReference> *thisptr = array_thisptr<rdcarray<DebugVariableReference>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_DebugVariableReference(PyObject *self, PyObject *vals)
{
  rdcarray<DebugVariableReference> *thisptr = array_thisptr<rdcarray<DebugVariableReference>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_DebugVariableReference(PyObject *self, Py_ssize_t count)
{
  rdcarray<DebugVariableReference> *thisptr = array_thisptr<rdcarray<DebugVariableReference>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_DebugVariableReference(PyObject *self, PyObject *vals)
{
  rdcarray<DebugVariableReference> *thisptr = array_thisptr<rdcarray<DebugVariableReference>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_DebugVariableReference(PyObject *self, Py_ssize_t count)
{
  rdcarray<DebugVariableReference> *thisptr = array_thisptr<rdcarray<DebugVariableReference>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_SourceVariableMapping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_SourceVariableMapping",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_SourceVariableMapping' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_SourceVariableMapping' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  rdcarray< SourceVariableMapping > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping___eq__' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping___eq__' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping___eq__' argument 2 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping___eq__' argument 2 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< SourceVariableMapping > const *)arg1)->operator ==((rdcarray< SourceVariableMapping > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  rdcarray< SourceVariableMapping > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping___ne__' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping___ne__' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping___ne__' argument 2 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping___ne__' argument 2 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< SourceVariableMapping > const *)arg1)->operator !=((rdcarray< SourceVariableMapping > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  rdcarray< SourceVariableMapping > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping___lt__' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping___lt__' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping___lt__' argument 2 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping___lt__' argument 2 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< SourceVariableMapping > const *)arg1)->operator <((rdcarray< SourceVariableMapping > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_resize_for_index' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_resize_for_index' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_SourceVariableMapping_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  size_t arg2 ;
  SourceVariableMapping *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SourceVariableMapping_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_fill' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_fill' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_SourceVariableMapping_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_SourceVariableMapping,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_SourceVariableMapping_fill" "', argument " "3"" of type '" "SourceVariableMapping const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_SourceVariableMapping_fill" "', argument " "3"" of type '" "SourceVariableMapping const &""'"); 
  }
  arg3 = reinterpret_cast< SourceVariableMapping * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(SourceVariableMapping const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SourceVariableMapping_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_pop_back' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_pop_back' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  SwigValueWrapper< std::function< bool (SourceVariableMapping const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_removeIf' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_removeIf' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (SourceVariableMapping const &) >>("rdcarray_of_SourceVariableMapping_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  SwigValueWrapper< std::function< bool (SourceVariableMapping const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_removeOneIf' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_removeOneIf' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (SourceVariableMapping const &) >>("rdcarray_of_SourceVariableMapping_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_append' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_append' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SourceVariableMapping_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SourceVariableMapping_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_clear' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_clear' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SourceVariableMapping_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SourceVariableMapping_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_insert' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_insert' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SourceVariableMapping_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_SourceVariableMapping_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_pop' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_pop' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SourceVariableMapping_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_SourceVariableMapping_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_sort' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_sort' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_SourceVariableMapping_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SourceVariableMapping_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SourceVariableMapping_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_copy' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_copy' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SourceVariableMapping_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SourceVariableMapping_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_reverse' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_reverse' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SourceVariableMapping_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_SourceVariableMapping_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_index' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_index' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SourceVariableMapping_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_count' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_count' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SourceVariableMapping_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_extend' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_extend' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SourceVariableMapping_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SourceVariableMapping_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SourceVariableMapping > *arg1 = (rdcarray< SourceVariableMapping > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SourceVariableMapping >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SourceVariableMapping_remove' argument 1 of type 'rdcarray< SourceVariableMapping >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SourceVariableMapping_remove' argument 1 of type 'rdcarray< SourceVariableMapping >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SourceVariableMapping_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_SourceVariableMapping) /* defines _wrap_delete_rdcarray_of_SourceVariableMapping_destructor_closure */


PyObject *repr_rdcarray_of_SourceVariableMapping(PyObject *self)
{
  rdcarray<SourceVariableMapping> *thisptr = array_thisptr<rdcarray<SourceVariableMapping>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_SourceVariableMapping(PyObject *self, Py_ssize_t idx)
{
  rdcarray<SourceVariableMapping> *thisptr = array_thisptr<rdcarray<SourceVariableMapping>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_SourceVariableMapping(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<SourceVariableMapping> *thisptr = array_thisptr<rdcarray<SourceVariableMapping>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_SourceVariableMapping(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<SourceVariableMapping> *thisptr = array_thisptr<rdcarray<SourceVariableMapping>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_SourceVariableMapping(PyObject *self, PyObject *idx)
{
  rdcarray<SourceVariableMapping> *thisptr = array_thisptr<rdcarray<SourceVariableMapping>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_SourceVariableMapping(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<SourceVariableMapping> *thisptr = array_thisptr<rdcarray<SourceVariableMapping>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_SourceVariableMapping(PyObject *self, PyObject *vals)
{
  rdcarray<SourceVariableMapping> *thisptr = array_thisptr<rdcarray<SourceVariableMapping>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_SourceVariableMapping(PyObject *self, Py_ssize_t count)
{
  rdcarray<SourceVariableMapping> *thisptr = array_thisptr<rdcarray<SourceVariableMapping>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_SourceVariableMapping(PyObject *self, PyObject *vals)
{
  rdcarray<SourceVariableMapping> *thisptr = array_thisptr<rdcarray<SourceVariableMapping>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_SourceVariableMapping(PyObject *self, Py_ssize_t count)
{
  rdcarray<SourceVariableMapping> *thisptr = array_thisptr<rdcarray<SourceVariableMapping>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_SigParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_SigParameter",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_SigParameter' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_SigParameter' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  rdcarray< SigParameter > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter___eq__' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter___eq__' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter___eq__' argument 2 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter___eq__' argument 2 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< SigParameter > const *)arg1)->operator ==((rdcarray< SigParameter > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  rdcarray< SigParameter > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter___ne__' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter___ne__' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter___ne__' argument 2 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter___ne__' argument 2 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< SigParameter > const *)arg1)->operator !=((rdcarray< SigParameter > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  rdcarray< SigParameter > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter___lt__' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter___lt__' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter___lt__' argument 2 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter___lt__' argument 2 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< SigParameter > const *)arg1)->operator <((rdcarray< SigParameter > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_resize_for_index' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_resize_for_index' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_SigParameter_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  size_t arg2 ;
  SigParameter *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SigParameter_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_fill' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_fill' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_SigParameter_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_SigParameter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_SigParameter_fill" "', argument " "3"" of type '" "SigParameter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_SigParameter_fill" "', argument " "3"" of type '" "SigParameter const &""'"); 
  }
  arg3 = reinterpret_cast< SigParameter * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(SigParameter const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SigParameter_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_pop_back' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_pop_back' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  SwigValueWrapper< std::function< bool (SigParameter const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_removeIf' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_removeIf' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (SigParameter const &) >>("rdcarray_of_SigParameter_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  SwigValueWrapper< std::function< bool (SigParameter const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_removeOneIf' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_removeOneIf' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (SigParameter const &) >>("rdcarray_of_SigParameter_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_append' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_append' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SigParameter_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SigParameter_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_clear' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_clear' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SigParameter_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SigParameter_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_insert' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_insert' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SigParameter_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_SigParameter_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_pop' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_pop' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SigParameter_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_SigParameter_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_sort' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_sort' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_SigParameter_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SigParameter_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SigParameter_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_copy' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_copy' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SigParameter_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SigParameter_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_reverse' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_reverse' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SigParameter_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_SigParameter_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_index' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_index' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SigParameter_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_count' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_count' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SigParameter_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_extend' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_extend' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SigParameter_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SigParameter_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SigParameter > *arg1 = (rdcarray< SigParameter > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SigParameter >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SigParameter_remove' argument 1 of type 'rdcarray< SigParameter >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SigParameter_remove' argument 1 of type 'rdcarray< SigParameter >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SigParameter_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_SigParameter) /* defines _wrap_delete_rdcarray_of_SigParameter_destructor_closure */


PyObject *repr_rdcarray_of_SigParameter(PyObject *self)
{
  rdcarray<SigParameter> *thisptr = array_thisptr<rdcarray<SigParameter>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_SigParameter(PyObject *self, Py_ssize_t idx)
{
  rdcarray<SigParameter> *thisptr = array_thisptr<rdcarray<SigParameter>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_SigParameter(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<SigParameter> *thisptr = array_thisptr<rdcarray<SigParameter>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_SigParameter(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<SigParameter> *thisptr = array_thisptr<rdcarray<SigParameter>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_SigParameter(PyObject *self, PyObject *idx)
{
  rdcarray<SigParameter> *thisptr = array_thisptr<rdcarray<SigParameter>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_SigParameter(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<SigParameter> *thisptr = array_thisptr<rdcarray<SigParameter>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_SigParameter(PyObject *self, PyObject *vals)
{
  rdcarray<SigParameter> *thisptr = array_thisptr<rdcarray<SigParameter>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_SigParameter(PyObject *self, Py_ssize_t count)
{
  rdcarray<SigParameter> *thisptr = array_thisptr<rdcarray<SigParameter>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_SigParameter(PyObject *self, PyObject *vals)
{
  rdcarray<SigParameter> *thisptr = array_thisptr<rdcarray<SigParameter>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_SigParameter(PyObject *self, Py_ssize_t count)
{
  rdcarray<SigParameter> *thisptr = array_thisptr<rdcarray<SigParameter>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_TextureDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_TextureDescription",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_TextureDescription' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_TextureDescription' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  rdcarray< TextureDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription___eq__' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription___eq__' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription___eq__' argument 2 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription___eq__' argument 2 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< TextureDescription > const *)arg1)->operator ==((rdcarray< TextureDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  rdcarray< TextureDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription___ne__' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription___ne__' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription___ne__' argument 2 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription___ne__' argument 2 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< TextureDescription > const *)arg1)->operator !=((rdcarray< TextureDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  rdcarray< TextureDescription > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription___lt__' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription___lt__' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription___lt__' argument 2 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription___lt__' argument 2 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< TextureDescription > const *)arg1)->operator <((rdcarray< TextureDescription > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_resize_for_index' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_resize_for_index' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_TextureDescription_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  size_t arg2 ;
  TextureDescription *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_TextureDescription_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_fill' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_fill' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_TextureDescription_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_TextureDescription,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_TextureDescription_fill" "', argument " "3"" of type '" "TextureDescription const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_TextureDescription_fill" "', argument " "3"" of type '" "TextureDescription const &""'"); 
  }
  arg3 = reinterpret_cast< TextureDescription * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(TextureDescription const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_TextureDescription_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_pop_back' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_pop_back' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  SwigValueWrapper< std::function< bool (TextureDescription const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_removeIf' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_removeIf' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (TextureDescription const &) >>("rdcarray_of_TextureDescription_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  SwigValueWrapper< std::function< bool (TextureDescription const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_removeOneIf' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_removeOneIf' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (TextureDescription const &) >>("rdcarray_of_TextureDescription_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_append' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_append' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TextureDescription_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_TextureDescription_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_clear' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_clear' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TextureDescription_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_TextureDescription_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_insert' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_insert' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TextureDescription_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_TextureDescription_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_pop' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_pop' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TextureDescription_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_TextureDescription_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_sort' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_sort' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_TextureDescription_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TextureDescription_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_TextureDescription_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_copy' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_copy' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TextureDescription_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_TextureDescription_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_reverse' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_reverse' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TextureDescription_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_TextureDescription_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_index' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_index' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TextureDescription_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_count' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_count' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TextureDescription_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_extend' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_extend' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TextureDescription_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_TextureDescription_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< TextureDescription > *arg1 = (rdcarray< TextureDescription > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< TextureDescription >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_TextureDescription_remove' argument 1 of type 'rdcarray< TextureDescription >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_TextureDescription_remove' argument 1 of type 'rdcarray< TextureDescription >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_TextureDescription_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_TextureDescription) /* defines _wrap_delete_rdcarray_of_TextureDescription_destructor_closure */


PyObject *repr_rdcarray_of_TextureDescription(PyObject *self)
{
  rdcarray<TextureDescription> *thisptr = array_thisptr<rdcarray<TextureDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_TextureDescription(PyObject *self, Py_ssize_t idx)
{
  rdcarray<TextureDescription> *thisptr = array_thisptr<rdcarray<TextureDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_TextureDescription(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<TextureDescription> *thisptr = array_thisptr<rdcarray<TextureDescription>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_TextureDescription(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<TextureDescription> *thisptr = array_thisptr<rdcarray<TextureDescription>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_TextureDescription(PyObject *self, PyObject *idx)
{
  rdcarray<TextureDescription> *thisptr = array_thisptr<rdcarray<TextureDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_TextureDescription(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<TextureDescription> *thisptr = array_thisptr<rdcarray<TextureDescription>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_TextureDescription(PyObject *self, PyObject *vals)
{
  rdcarray<TextureDescription> *thisptr = array_thisptr<rdcarray<TextureDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_TextureDescription(PyObject *self, Py_ssize_t count)
{
  rdcarray<TextureDescription> *thisptr = array_thisptr<rdcarray<TextureDescription>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_TextureDescription(PyObject *self, PyObject *vals)
{
  rdcarray<TextureDescription> *thisptr = array_thisptr<rdcarray<TextureDescription>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_TextureDescription(PyObject *self, Py_ssize_t count)
{
  rdcarray<TextureDescription> *thisptr = array_thisptr<rdcarray<TextureDescription>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderEntryPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderEntryPoint",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderEntryPoint' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderEntryPoint' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  rdcarray< ShaderEntryPoint > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint___eq__' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint___eq__' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint___eq__' argument 2 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint___eq__' argument 2 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderEntryPoint > const *)arg1)->operator ==((rdcarray< ShaderEntryPoint > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  rdcarray< ShaderEntryPoint > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint___ne__' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint___ne__' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint___ne__' argument 2 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint___ne__' argument 2 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderEntryPoint > const *)arg1)->operator !=((rdcarray< ShaderEntryPoint > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  rdcarray< ShaderEntryPoint > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint___lt__' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint___lt__' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint___lt__' argument 2 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint___lt__' argument 2 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderEntryPoint > const *)arg1)->operator <((rdcarray< ShaderEntryPoint > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_resize_for_index' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_resize_for_index' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderEntryPoint_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  size_t arg2 ;
  ShaderEntryPoint *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderEntryPoint_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_fill' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_fill' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderEntryPoint_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ShaderEntryPoint,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ShaderEntryPoint_fill" "', argument " "3"" of type '" "ShaderEntryPoint const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ShaderEntryPoint_fill" "', argument " "3"" of type '" "ShaderEntryPoint const &""'"); 
  }
  arg3 = reinterpret_cast< ShaderEntryPoint * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderEntryPoint const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderEntryPoint_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_pop_back' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_pop_back' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderEntryPoint const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_removeIf' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_removeIf' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderEntryPoint const &) >>("rdcarray_of_ShaderEntryPoint_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderEntryPoint const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_removeOneIf' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_removeOneIf' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderEntryPoint const &) >>("rdcarray_of_ShaderEntryPoint_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_append' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_append' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEntryPoint_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderEntryPoint_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_clear' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_clear' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEntryPoint_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderEntryPoint_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_insert' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_insert' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEntryPoint_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderEntryPoint_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_pop' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_pop' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEntryPoint_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderEntryPoint_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_sort' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_sort' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderEntryPoint_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEntryPoint_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderEntryPoint_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_copy' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_copy' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEntryPoint_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderEntryPoint_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_reverse' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_reverse' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEntryPoint_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderEntryPoint_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_index' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_index' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEntryPoint_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_count' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_count' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEntryPoint_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_extend' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_extend' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEntryPoint_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderEntryPoint_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderEntryPoint > *arg1 = (rdcarray< ShaderEntryPoint > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderEntryPoint >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderEntryPoint_remove' argument 1 of type 'rdcarray< ShaderEntryPoint >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderEntryPoint_remove' argument 1 of type 'rdcarray< ShaderEntryPoint >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderEntryPoint_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderEntryPoint) /* defines _wrap_delete_rdcarray_of_ShaderEntryPoint_destructor_closure */


PyObject *repr_rdcarray_of_ShaderEntryPoint(PyObject *self)
{
  rdcarray<ShaderEntryPoint> *thisptr = array_thisptr<rdcarray<ShaderEntryPoint>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderEntryPoint(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderEntryPoint> *thisptr = array_thisptr<rdcarray<ShaderEntryPoint>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderEntryPoint(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderEntryPoint> *thisptr = array_thisptr<rdcarray<ShaderEntryPoint>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderEntryPoint(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderEntryPoint> *thisptr = array_thisptr<rdcarray<ShaderEntryPoint>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderEntryPoint(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderEntryPoint> *thisptr = array_thisptr<rdcarray<ShaderEntryPoint>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderEntryPoint(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderEntryPoint> *thisptr = array_thisptr<rdcarray<ShaderEntryPoint>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderEntryPoint(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderEntryPoint> *thisptr = array_thisptr<rdcarray<ShaderEntryPoint>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderEntryPoint(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderEntryPoint> *thisptr = array_thisptr<rdcarray<ShaderEntryPoint>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderEntryPoint(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderEntryPoint> *thisptr = array_thisptr<rdcarray<ShaderEntryPoint>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderEntryPoint(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderEntryPoint> *thisptr = array_thisptr<rdcarray<ShaderEntryPoint>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_Viewport(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_Viewport",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_Viewport' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_Viewport' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  rdcarray< Viewport > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport___eq__' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport___eq__' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport___eq__' argument 2 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport___eq__' argument 2 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< Viewport > const *)arg1)->operator ==((rdcarray< Viewport > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  rdcarray< Viewport > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport___ne__' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport___ne__' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport___ne__' argument 2 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport___ne__' argument 2 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< Viewport > const *)arg1)->operator !=((rdcarray< Viewport > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  rdcarray< Viewport > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport___lt__' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport___lt__' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport___lt__' argument 2 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport___lt__' argument 2 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< Viewport > const *)arg1)->operator <((rdcarray< Viewport > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_resize_for_index' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_resize_for_index' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_Viewport_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  size_t arg2 ;
  Viewport *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Viewport_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_fill' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_fill' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_Viewport_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_Viewport,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_Viewport_fill" "', argument " "3"" of type '" "Viewport const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_Viewport_fill" "', argument " "3"" of type '" "Viewport const &""'"); 
  }
  arg3 = reinterpret_cast< Viewport * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(Viewport const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Viewport_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_pop_back' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_pop_back' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  SwigValueWrapper< std::function< bool (Viewport const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_removeIf' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_removeIf' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (Viewport const &) >>("rdcarray_of_Viewport_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  SwigValueWrapper< std::function< bool (Viewport const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_removeOneIf' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_removeOneIf' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (Viewport const &) >>("rdcarray_of_Viewport_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_append' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_append' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Viewport_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Viewport_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_clear' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_clear' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Viewport_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Viewport_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_insert' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_insert' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Viewport_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_Viewport_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_pop' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_pop' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Viewport_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_Viewport_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_sort' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_sort' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_Viewport_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Viewport_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Viewport_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_copy' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_copy' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Viewport_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Viewport_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_reverse' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_reverse' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Viewport_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_Viewport_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_index' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_index' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Viewport_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_count' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_count' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Viewport_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_extend' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_extend' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Viewport_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Viewport_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Viewport > *arg1 = (rdcarray< Viewport > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Viewport >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Viewport_remove' argument 1 of type 'rdcarray< Viewport >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Viewport_remove' argument 1 of type 'rdcarray< Viewport >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Viewport_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_Viewport) /* defines _wrap_delete_rdcarray_of_Viewport_destructor_closure */


PyObject *repr_rdcarray_of_Viewport(PyObject *self)
{
  rdcarray<Viewport> *thisptr = array_thisptr<rdcarray<Viewport>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_Viewport(PyObject *self, Py_ssize_t idx)
{
  rdcarray<Viewport> *thisptr = array_thisptr<rdcarray<Viewport>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_Viewport(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<Viewport> *thisptr = array_thisptr<rdcarray<Viewport>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_Viewport(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<Viewport> *thisptr = array_thisptr<rdcarray<Viewport>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_Viewport(PyObject *self, PyObject *idx)
{
  rdcarray<Viewport> *thisptr = array_thisptr<rdcarray<Viewport>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_Viewport(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<Viewport> *thisptr = array_thisptr<rdcarray<Viewport>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_Viewport(PyObject *self, PyObject *vals)
{
  rdcarray<Viewport> *thisptr = array_thisptr<rdcarray<Viewport>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_Viewport(PyObject *self, Py_ssize_t count)
{
  rdcarray<Viewport> *thisptr = array_thisptr<rdcarray<Viewport>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_Viewport(PyObject *self, PyObject *vals)
{
  rdcarray<Viewport> *thisptr = array_thisptr<rdcarray<Viewport>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_Viewport(PyObject *self, Py_ssize_t count)
{
  rdcarray<Viewport> *thisptr = array_thisptr<rdcarray<Viewport>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_Scissor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_Scissor",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_Scissor' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_Scissor' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  rdcarray< Scissor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor___eq__' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor___eq__' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor___eq__' argument 2 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor___eq__' argument 2 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< Scissor > const *)arg1)->operator ==((rdcarray< Scissor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  rdcarray< Scissor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor___ne__' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor___ne__' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor___ne__' argument 2 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor___ne__' argument 2 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< Scissor > const *)arg1)->operator !=((rdcarray< Scissor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  rdcarray< Scissor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor___lt__' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor___lt__' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor___lt__' argument 2 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor___lt__' argument 2 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< Scissor > const *)arg1)->operator <((rdcarray< Scissor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_resize_for_index' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_resize_for_index' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_Scissor_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  size_t arg2 ;
  Scissor *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Scissor_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_fill' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_fill' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_Scissor_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_Scissor,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_Scissor_fill" "', argument " "3"" of type '" "Scissor const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_Scissor_fill" "', argument " "3"" of type '" "Scissor const &""'"); 
  }
  arg3 = reinterpret_cast< Scissor * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(Scissor const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Scissor_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_pop_back' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_pop_back' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  SwigValueWrapper< std::function< bool (Scissor const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_removeIf' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_removeIf' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (Scissor const &) >>("rdcarray_of_Scissor_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  SwigValueWrapper< std::function< bool (Scissor const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_removeOneIf' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_removeOneIf' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (Scissor const &) >>("rdcarray_of_Scissor_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_append' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_append' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Scissor_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Scissor_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_clear' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_clear' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Scissor_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Scissor_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_insert' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_insert' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Scissor_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_Scissor_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_pop' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_pop' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Scissor_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_Scissor_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_sort' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_sort' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_Scissor_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Scissor_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Scissor_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_copy' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_copy' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Scissor_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Scissor_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_reverse' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_reverse' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Scissor_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_Scissor_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_index' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_index' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Scissor_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_count' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_count' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Scissor_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_extend' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_extend' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Scissor_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Scissor_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Scissor > *arg1 = (rdcarray< Scissor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Scissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Scissor_remove' argument 1 of type 'rdcarray< Scissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Scissor_remove' argument 1 of type 'rdcarray< Scissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Scissor_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_Scissor) /* defines _wrap_delete_rdcarray_of_Scissor_destructor_closure */


PyObject *repr_rdcarray_of_Scissor(PyObject *self)
{
  rdcarray<Scissor> *thisptr = array_thisptr<rdcarray<Scissor>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_Scissor(PyObject *self, Py_ssize_t idx)
{
  rdcarray<Scissor> *thisptr = array_thisptr<rdcarray<Scissor>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_Scissor(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<Scissor> *thisptr = array_thisptr<rdcarray<Scissor>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_Scissor(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<Scissor> *thisptr = array_thisptr<rdcarray<Scissor>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_Scissor(PyObject *self, PyObject *idx)
{
  rdcarray<Scissor> *thisptr = array_thisptr<rdcarray<Scissor>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_Scissor(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<Scissor> *thisptr = array_thisptr<rdcarray<Scissor>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_Scissor(PyObject *self, PyObject *vals)
{
  rdcarray<Scissor> *thisptr = array_thisptr<rdcarray<Scissor>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_Scissor(PyObject *self, Py_ssize_t count)
{
  rdcarray<Scissor> *thisptr = array_thisptr<rdcarray<Scissor>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_Scissor(PyObject *self, PyObject *vals)
{
  rdcarray<Scissor> *thisptr = array_thisptr<rdcarray<Scissor>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_Scissor(PyObject *self, Py_ssize_t count)
{
  rdcarray<Scissor> *thisptr = array_thisptr<rdcarray<Scissor>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ColorBlend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ColorBlend",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ColorBlend' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ColorBlend' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  rdcarray< ColorBlend > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend___eq__' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend___eq__' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend___eq__' argument 2 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend___eq__' argument 2 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ColorBlend > const *)arg1)->operator ==((rdcarray< ColorBlend > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  rdcarray< ColorBlend > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend___ne__' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend___ne__' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend___ne__' argument 2 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend___ne__' argument 2 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ColorBlend > const *)arg1)->operator !=((rdcarray< ColorBlend > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  rdcarray< ColorBlend > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend___lt__' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend___lt__' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend___lt__' argument 2 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend___lt__' argument 2 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ColorBlend > const *)arg1)->operator <((rdcarray< ColorBlend > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_resize_for_index' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_resize_for_index' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ColorBlend_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  size_t arg2 ;
  ColorBlend *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ColorBlend_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_fill' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_fill' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ColorBlend_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ColorBlend,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ColorBlend_fill" "', argument " "3"" of type '" "ColorBlend const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ColorBlend_fill" "', argument " "3"" of type '" "ColorBlend const &""'"); 
  }
  arg3 = reinterpret_cast< ColorBlend * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ColorBlend const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ColorBlend_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_pop_back' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_pop_back' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  SwigValueWrapper< std::function< bool (ColorBlend const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_removeIf' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_removeIf' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ColorBlend const &) >>("rdcarray_of_ColorBlend_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  SwigValueWrapper< std::function< bool (ColorBlend const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_removeOneIf' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_removeOneIf' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ColorBlend const &) >>("rdcarray_of_ColorBlend_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_append' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_append' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ColorBlend_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ColorBlend_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_clear' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_clear' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ColorBlend_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ColorBlend_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_insert' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_insert' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ColorBlend_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ColorBlend_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_pop' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_pop' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ColorBlend_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ColorBlend_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_sort' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_sort' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ColorBlend_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ColorBlend_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ColorBlend_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_copy' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_copy' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ColorBlend_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ColorBlend_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_reverse' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_reverse' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ColorBlend_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ColorBlend_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_index' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_index' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ColorBlend_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_count' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_count' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ColorBlend_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_extend' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_extend' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ColorBlend_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ColorBlend_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ColorBlend > *arg1 = (rdcarray< ColorBlend > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ColorBlend >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ColorBlend_remove' argument 1 of type 'rdcarray< ColorBlend >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ColorBlend_remove' argument 1 of type 'rdcarray< ColorBlend >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ColorBlend_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ColorBlend) /* defines _wrap_delete_rdcarray_of_ColorBlend_destructor_closure */


PyObject *repr_rdcarray_of_ColorBlend(PyObject *self)
{
  rdcarray<ColorBlend> *thisptr = array_thisptr<rdcarray<ColorBlend>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ColorBlend(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ColorBlend> *thisptr = array_thisptr<rdcarray<ColorBlend>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ColorBlend(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ColorBlend> *thisptr = array_thisptr<rdcarray<ColorBlend>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ColorBlend(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ColorBlend> *thisptr = array_thisptr<rdcarray<ColorBlend>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ColorBlend(PyObject *self, PyObject *idx)
{
  rdcarray<ColorBlend> *thisptr = array_thisptr<rdcarray<ColorBlend>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ColorBlend(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ColorBlend> *thisptr = array_thisptr<rdcarray<ColorBlend>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ColorBlend(PyObject *self, PyObject *vals)
{
  rdcarray<ColorBlend> *thisptr = array_thisptr<rdcarray<ColorBlend>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ColorBlend(PyObject *self, Py_ssize_t count)
{
  rdcarray<ColorBlend> *thisptr = array_thisptr<rdcarray<ColorBlend>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ColorBlend(PyObject *self, PyObject *vals)
{
  rdcarray<ColorBlend> *thisptr = array_thisptr<rdcarray<ColorBlend>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ColorBlend(PyObject *self, Py_ssize_t count)
{
  rdcarray<ColorBlend> *thisptr = array_thisptr<rdcarray<ColorBlend>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_BoundVBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_BoundVBuffer",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_BoundVBuffer' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_BoundVBuffer' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  rdcarray< BoundVBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer___eq__' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer___eq__' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer___eq__' argument 2 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer___eq__' argument 2 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< BoundVBuffer > const *)arg1)->operator ==((rdcarray< BoundVBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  rdcarray< BoundVBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer___ne__' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer___ne__' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer___ne__' argument 2 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer___ne__' argument 2 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< BoundVBuffer > const *)arg1)->operator !=((rdcarray< BoundVBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  rdcarray< BoundVBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer___lt__' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer___lt__' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer___lt__' argument 2 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer___lt__' argument 2 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< BoundVBuffer > const *)arg1)->operator <((rdcarray< BoundVBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_resize_for_index' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_resize_for_index' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_BoundVBuffer_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  size_t arg2 ;
  BoundVBuffer *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_BoundVBuffer_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_fill' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_fill' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_BoundVBuffer_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_BoundVBuffer,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_BoundVBuffer_fill" "', argument " "3"" of type '" "BoundVBuffer const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_BoundVBuffer_fill" "', argument " "3"" of type '" "BoundVBuffer const &""'"); 
  }
  arg3 = reinterpret_cast< BoundVBuffer * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(BoundVBuffer const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_BoundVBuffer_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_pop_back' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_pop_back' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (BoundVBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_removeIf' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_removeIf' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (BoundVBuffer const &) >>("rdcarray_of_BoundVBuffer_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (BoundVBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_removeOneIf' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_removeOneIf' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (BoundVBuffer const &) >>("rdcarray_of_BoundVBuffer_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_append' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_append' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BoundVBuffer_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_BoundVBuffer_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_clear' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_clear' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BoundVBuffer_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_BoundVBuffer_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_insert' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_insert' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BoundVBuffer_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_BoundVBuffer_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_pop' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_pop' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BoundVBuffer_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_BoundVBuffer_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_sort' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_sort' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_BoundVBuffer_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BoundVBuffer_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_BoundVBuffer_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_copy' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_copy' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BoundVBuffer_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_BoundVBuffer_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_reverse' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_reverse' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BoundVBuffer_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_BoundVBuffer_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_index' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_index' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BoundVBuffer_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_count' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_count' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BoundVBuffer_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_extend' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_extend' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BoundVBuffer_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_BoundVBuffer_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< BoundVBuffer > *arg1 = (rdcarray< BoundVBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< BoundVBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_BoundVBuffer_remove' argument 1 of type 'rdcarray< BoundVBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_BoundVBuffer_remove' argument 1 of type 'rdcarray< BoundVBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_BoundVBuffer_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_BoundVBuffer) /* defines _wrap_delete_rdcarray_of_BoundVBuffer_destructor_closure */


PyObject *repr_rdcarray_of_BoundVBuffer(PyObject *self)
{
  rdcarray<BoundVBuffer> *thisptr = array_thisptr<rdcarray<BoundVBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_BoundVBuffer(PyObject *self, Py_ssize_t idx)
{
  rdcarray<BoundVBuffer> *thisptr = array_thisptr<rdcarray<BoundVBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_BoundVBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<BoundVBuffer> *thisptr = array_thisptr<rdcarray<BoundVBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_BoundVBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<BoundVBuffer> *thisptr = array_thisptr<rdcarray<BoundVBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_BoundVBuffer(PyObject *self, PyObject *idx)
{
  rdcarray<BoundVBuffer> *thisptr = array_thisptr<rdcarray<BoundVBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_BoundVBuffer(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<BoundVBuffer> *thisptr = array_thisptr<rdcarray<BoundVBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_BoundVBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<BoundVBuffer> *thisptr = array_thisptr<rdcarray<BoundVBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_BoundVBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<BoundVBuffer> *thisptr = array_thisptr<rdcarray<BoundVBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_BoundVBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<BoundVBuffer> *thisptr = array_thisptr<rdcarray<BoundVBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_BoundVBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<BoundVBuffer> *thisptr = array_thisptr<rdcarray<BoundVBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_Offset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_Offset",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_Offset' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_Offset' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  rdcarray< Offset > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset___eq__' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset___eq__' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset___eq__' argument 2 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset___eq__' argument 2 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< Offset > const *)arg1)->operator ==((rdcarray< Offset > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  rdcarray< Offset > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset___ne__' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset___ne__' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset___ne__' argument 2 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset___ne__' argument 2 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< Offset > const *)arg1)->operator !=((rdcarray< Offset > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  rdcarray< Offset > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset___lt__' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset___lt__' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset___lt__' argument 2 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset___lt__' argument 2 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< Offset > const *)arg1)->operator <((rdcarray< Offset > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_resize_for_index' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_resize_for_index' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_Offset_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  size_t arg2 ;
  Offset *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Offset_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_fill' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_fill' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_Offset_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_Offset,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_Offset_fill" "', argument " "3"" of type '" "Offset const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_Offset_fill" "', argument " "3"" of type '" "Offset const &""'"); 
  }
  arg3 = reinterpret_cast< Offset * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(Offset const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Offset_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_pop_back' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_pop_back' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  SwigValueWrapper< std::function< bool (Offset const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_removeIf' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_removeIf' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (Offset const &) >>("rdcarray_of_Offset_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  SwigValueWrapper< std::function< bool (Offset const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_removeOneIf' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_removeOneIf' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (Offset const &) >>("rdcarray_of_Offset_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_append' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_append' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Offset_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Offset_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_clear' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_clear' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Offset_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Offset_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_insert' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_insert' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Offset_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_Offset_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_pop' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_pop' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Offset_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_Offset_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_sort' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_sort' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_Offset_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Offset_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Offset_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_copy' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_copy' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Offset_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Offset_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_reverse' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_reverse' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Offset_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_Offset_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_index' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_index' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Offset_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_count' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_count' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Offset_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_extend' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_extend' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Offset_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Offset_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Offset > *arg1 = (rdcarray< Offset > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Offset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Offset_remove' argument 1 of type 'rdcarray< Offset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Offset_remove' argument 1 of type 'rdcarray< Offset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Offset_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_Offset) /* defines _wrap_delete_rdcarray_of_Offset_destructor_closure */


PyObject *repr_rdcarray_of_Offset(PyObject *self)
{
  rdcarray<Offset> *thisptr = array_thisptr<rdcarray<Offset>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_Offset(PyObject *self, Py_ssize_t idx)
{
  rdcarray<Offset> *thisptr = array_thisptr<rdcarray<Offset>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_Offset(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<Offset> *thisptr = array_thisptr<rdcarray<Offset>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_Offset(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<Offset> *thisptr = array_thisptr<rdcarray<Offset>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_Offset(PyObject *self, PyObject *idx)
{
  rdcarray<Offset> *thisptr = array_thisptr<rdcarray<Offset>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_Offset(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<Offset> *thisptr = array_thisptr<rdcarray<Offset>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_Offset(PyObject *self, PyObject *vals)
{
  rdcarray<Offset> *thisptr = array_thisptr<rdcarray<Offset>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_Offset(PyObject *self, Py_ssize_t count)
{
  rdcarray<Offset> *thisptr = array_thisptr<rdcarray<Offset>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_Offset(PyObject *self, PyObject *vals)
{
  rdcarray<Offset> *thisptr = array_thisptr<rdcarray<Offset>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_Offset(PyObject *self, Py_ssize_t count)
{
  rdcarray<Offset> *thisptr = array_thisptr<rdcarray<Offset>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_VertexInputAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_VertexInputAttribute",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_VertexInputAttribute' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_VertexInputAttribute' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  rdcarray< VertexInputAttribute > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute___eq__' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute___eq__' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute___eq__' argument 2 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute___eq__' argument 2 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VertexInputAttribute > const *)arg1)->operator ==((rdcarray< VertexInputAttribute > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  rdcarray< VertexInputAttribute > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute___ne__' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute___ne__' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute___ne__' argument 2 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute___ne__' argument 2 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VertexInputAttribute > const *)arg1)->operator !=((rdcarray< VertexInputAttribute > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  rdcarray< VertexInputAttribute > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute___lt__' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute___lt__' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute___lt__' argument 2 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute___lt__' argument 2 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VertexInputAttribute > const *)arg1)->operator <((rdcarray< VertexInputAttribute > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_resize_for_index' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_resize_for_index' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VertexInputAttribute_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  size_t arg2 ;
  VertexInputAttribute *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VertexInputAttribute_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_fill' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_fill' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VertexInputAttribute_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_VertexInputAttribute,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_VertexInputAttribute_fill" "', argument " "3"" of type '" "VertexInputAttribute const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_VertexInputAttribute_fill" "', argument " "3"" of type '" "VertexInputAttribute const &""'"); 
  }
  arg3 = reinterpret_cast< VertexInputAttribute * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(VertexInputAttribute const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VertexInputAttribute_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_pop_back' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_pop_back' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  SwigValueWrapper< std::function< bool (VertexInputAttribute const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_removeIf' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_removeIf' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VertexInputAttribute const &) >>("rdcarray_of_VertexInputAttribute_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  SwigValueWrapper< std::function< bool (VertexInputAttribute const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_removeOneIf' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_removeOneIf' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VertexInputAttribute const &) >>("rdcarray_of_VertexInputAttribute_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_append' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_append' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VertexInputAttribute_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VertexInputAttribute_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_clear' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_clear' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VertexInputAttribute_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VertexInputAttribute_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_insert' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_insert' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VertexInputAttribute_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_VertexInputAttribute_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_pop' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_pop' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VertexInputAttribute_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_VertexInputAttribute_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_sort' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_sort' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_VertexInputAttribute_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VertexInputAttribute_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VertexInputAttribute_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_copy' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_copy' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VertexInputAttribute_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VertexInputAttribute_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_reverse' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_reverse' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VertexInputAttribute_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_VertexInputAttribute_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_index' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_index' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VertexInputAttribute_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_count' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_count' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VertexInputAttribute_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_extend' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_extend' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VertexInputAttribute_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VertexInputAttribute_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VertexInputAttribute > *arg1 = (rdcarray< VertexInputAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VertexInputAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VertexInputAttribute_remove' argument 1 of type 'rdcarray< VertexInputAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VertexInputAttribute_remove' argument 1 of type 'rdcarray< VertexInputAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VertexInputAttribute_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_VertexInputAttribute) /* defines _wrap_delete_rdcarray_of_VertexInputAttribute_destructor_closure */


PyObject *repr_rdcarray_of_VertexInputAttribute(PyObject *self)
{
  rdcarray<VertexInputAttribute> *thisptr = array_thisptr<rdcarray<VertexInputAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_VertexInputAttribute(PyObject *self, Py_ssize_t idx)
{
  rdcarray<VertexInputAttribute> *thisptr = array_thisptr<rdcarray<VertexInputAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_VertexInputAttribute(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VertexInputAttribute> *thisptr = array_thisptr<rdcarray<VertexInputAttribute>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_VertexInputAttribute(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VertexInputAttribute> *thisptr = array_thisptr<rdcarray<VertexInputAttribute>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_VertexInputAttribute(PyObject *self, PyObject *idx)
{
  rdcarray<VertexInputAttribute> *thisptr = array_thisptr<rdcarray<VertexInputAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_VertexInputAttribute(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<VertexInputAttribute> *thisptr = array_thisptr<rdcarray<VertexInputAttribute>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_VertexInputAttribute(PyObject *self, PyObject *vals)
{
  rdcarray<VertexInputAttribute> *thisptr = array_thisptr<rdcarray<VertexInputAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_VertexInputAttribute(PyObject *self, Py_ssize_t count)
{
  rdcarray<VertexInputAttribute> *thisptr = array_thisptr<rdcarray<VertexInputAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_VertexInputAttribute(PyObject *self, PyObject *vals)
{
  rdcarray<VertexInputAttribute> *thisptr = array_thisptr<rdcarray<VertexInputAttribute>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_VertexInputAttribute(PyObject *self, Py_ssize_t count)
{
  rdcarray<VertexInputAttribute> *thisptr = array_thisptr<rdcarray<VertexInputAttribute>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_FloatVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_FloatVector",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_FloatVector' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_FloatVector' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  rdcarray< FloatVector > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector___eq__' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector___eq__' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector___eq__' argument 2 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector___eq__' argument 2 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< FloatVector > const *)arg1)->operator ==((rdcarray< FloatVector > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  rdcarray< FloatVector > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector___ne__' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector___ne__' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector___ne__' argument 2 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector___ne__' argument 2 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< FloatVector > const *)arg1)->operator !=((rdcarray< FloatVector > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  rdcarray< FloatVector > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector___lt__' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector___lt__' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector___lt__' argument 2 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector___lt__' argument 2 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< FloatVector > const *)arg1)->operator <((rdcarray< FloatVector > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_resize_for_index' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_resize_for_index' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_FloatVector_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  size_t arg2 ;
  FloatVector *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_FloatVector_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_fill' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_fill' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_FloatVector_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_FloatVector,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_FloatVector_fill" "', argument " "3"" of type '" "FloatVector const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_FloatVector_fill" "', argument " "3"" of type '" "FloatVector const &""'"); 
  }
  arg3 = reinterpret_cast< FloatVector * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(FloatVector const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_FloatVector_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_pop_back' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_pop_back' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  SwigValueWrapper< std::function< bool (FloatVector const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_removeIf' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_removeIf' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (FloatVector const &) >>("rdcarray_of_FloatVector_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  SwigValueWrapper< std::function< bool (FloatVector const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_removeOneIf' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_removeOneIf' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (FloatVector const &) >>("rdcarray_of_FloatVector_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_append' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_append' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_FloatVector_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_FloatVector_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_clear' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_clear' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_FloatVector_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_FloatVector_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_insert' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_insert' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_FloatVector_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_FloatVector_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_pop' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_pop' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_FloatVector_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_FloatVector_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_sort' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_sort' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_FloatVector_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_FloatVector_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_FloatVector_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_copy' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_copy' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_FloatVector_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_FloatVector_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_reverse' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_reverse' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_FloatVector_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_FloatVector_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_index' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_index' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_FloatVector_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_count' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_count' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_FloatVector_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_extend' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_extend' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_FloatVector_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_FloatVector_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< FloatVector > *arg1 = (rdcarray< FloatVector > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< FloatVector >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_FloatVector_remove' argument 1 of type 'rdcarray< FloatVector >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_FloatVector_remove' argument 1 of type 'rdcarray< FloatVector >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_FloatVector_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_FloatVector) /* defines _wrap_delete_rdcarray_of_FloatVector_destructor_closure */


PyObject *repr_rdcarray_of_FloatVector(PyObject *self)
{
  rdcarray<FloatVector> *thisptr = array_thisptr<rdcarray<FloatVector>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_FloatVector(PyObject *self, Py_ssize_t idx)
{
  rdcarray<FloatVector> *thisptr = array_thisptr<rdcarray<FloatVector>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_FloatVector(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<FloatVector> *thisptr = array_thisptr<rdcarray<FloatVector>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_FloatVector(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<FloatVector> *thisptr = array_thisptr<rdcarray<FloatVector>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_FloatVector(PyObject *self, PyObject *idx)
{
  rdcarray<FloatVector> *thisptr = array_thisptr<rdcarray<FloatVector>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_FloatVector(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<FloatVector> *thisptr = array_thisptr<rdcarray<FloatVector>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_FloatVector(PyObject *self, PyObject *vals)
{
  rdcarray<FloatVector> *thisptr = array_thisptr<rdcarray<FloatVector>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_FloatVector(PyObject *self, Py_ssize_t count)
{
  rdcarray<FloatVector> *thisptr = array_thisptr<rdcarray<FloatVector>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_FloatVector(PyObject *self, PyObject *vals)
{
  rdcarray<FloatVector> *thisptr = array_thisptr<rdcarray<FloatVector>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_FloatVector(PyObject *self, Py_ssize_t count)
{
  rdcarray<FloatVector> *thisptr = array_thisptr<rdcarray<FloatVector>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_GraphicsAPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_GraphicsAPI",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_GraphicsAPI' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_GraphicsAPI' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  rdcarray< GraphicsAPI > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI___eq__' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI___eq__' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI___eq__' argument 2 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI___eq__' argument 2 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GraphicsAPI > const *)arg1)->operator ==((rdcarray< GraphicsAPI > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  rdcarray< GraphicsAPI > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI___ne__' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI___ne__' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI___ne__' argument 2 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI___ne__' argument 2 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GraphicsAPI > const *)arg1)->operator !=((rdcarray< GraphicsAPI > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  rdcarray< GraphicsAPI > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI___lt__' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI___lt__' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI___lt__' argument 2 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI___lt__' argument 2 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GraphicsAPI > const *)arg1)->operator <((rdcarray< GraphicsAPI > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_resize_for_index' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_resize_for_index' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_GraphicsAPI_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  size_t arg2 ;
  GraphicsAPI *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 ;
  GraphicsAPI temp3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GraphicsAPI_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_fill' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_fill' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_GraphicsAPI_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int (swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_GraphicsAPI_fill" "', argument " "3"" of type '" "GraphicsAPI const &""'");
  } else {
    temp3 = static_cast< GraphicsAPI >(val3);
    arg3 = &temp3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(GraphicsAPI const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GraphicsAPI_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_pop_back' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_pop_back' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  std::function< bool (GraphicsAPI const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_removeIf' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_removeIf' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (GraphicsAPI const &) >>("rdcarray_of_GraphicsAPI_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  std::function< bool (GraphicsAPI const &) > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_removeOneIf' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_removeOneIf' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (GraphicsAPI const &) >>("rdcarray_of_GraphicsAPI_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_append' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_append' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GraphicsAPI_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GraphicsAPI_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_clear' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_clear' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GraphicsAPI_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GraphicsAPI_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_insert' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_insert' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GraphicsAPI_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_GraphicsAPI_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_pop' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_pop' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GraphicsAPI_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_GraphicsAPI_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_sort' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_sort' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_GraphicsAPI_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GraphicsAPI_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GraphicsAPI_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_copy' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_copy' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GraphicsAPI_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GraphicsAPI_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_reverse' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_reverse' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GraphicsAPI_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_GraphicsAPI_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_index' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_index' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GraphicsAPI_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_count' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_count' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GraphicsAPI_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_extend' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_extend' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GraphicsAPI_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GraphicsAPI_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GraphicsAPI > *arg1 = (rdcarray< GraphicsAPI > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GraphicsAPI >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GraphicsAPI_remove' argument 1 of type 'rdcarray< GraphicsAPI >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GraphicsAPI_remove' argument 1 of type 'rdcarray< GraphicsAPI >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GraphicsAPI_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_GraphicsAPI) /* defines _wrap_delete_rdcarray_of_GraphicsAPI_destructor_closure */


PyObject *repr_rdcarray_of_GraphicsAPI(PyObject *self)
{
  rdcarray<GraphicsAPI> *thisptr = array_thisptr<rdcarray<GraphicsAPI>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_GraphicsAPI(PyObject *self, Py_ssize_t idx)
{
  rdcarray<GraphicsAPI> *thisptr = array_thisptr<rdcarray<GraphicsAPI>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_GraphicsAPI(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<GraphicsAPI> *thisptr = array_thisptr<rdcarray<GraphicsAPI>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_GraphicsAPI(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<GraphicsAPI> *thisptr = array_thisptr<rdcarray<GraphicsAPI>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_GraphicsAPI(PyObject *self, PyObject *idx)
{
  rdcarray<GraphicsAPI> *thisptr = array_thisptr<rdcarray<GraphicsAPI>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_GraphicsAPI(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<GraphicsAPI> *thisptr = array_thisptr<rdcarray<GraphicsAPI>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_GraphicsAPI(PyObject *self, PyObject *vals)
{
  rdcarray<GraphicsAPI> *thisptr = array_thisptr<rdcarray<GraphicsAPI>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_GraphicsAPI(PyObject *self, Py_ssize_t count)
{
  rdcarray<GraphicsAPI> *thisptr = array_thisptr<rdcarray<GraphicsAPI>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_GraphicsAPI(PyObject *self, PyObject *vals)
{
  rdcarray<GraphicsAPI> *thisptr = array_thisptr<rdcarray<GraphicsAPI>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_GraphicsAPI(PyObject *self, Py_ssize_t count)
{
  rdcarray<GraphicsAPI> *thisptr = array_thisptr<rdcarray<GraphicsAPI>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_GPUDevice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_GPUDevice",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_GPUDevice' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_GPUDevice' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  rdcarray< GPUDevice > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice___eq__' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice___eq__' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice___eq__' argument 2 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice___eq__' argument 2 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GPUDevice > const *)arg1)->operator ==((rdcarray< GPUDevice > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  rdcarray< GPUDevice > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice___ne__' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice___ne__' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice___ne__' argument 2 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice___ne__' argument 2 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GPUDevice > const *)arg1)->operator !=((rdcarray< GPUDevice > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  rdcarray< GPUDevice > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice___lt__' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice___lt__' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice___lt__' argument 2 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice___lt__' argument 2 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GPUDevice > const *)arg1)->operator <((rdcarray< GPUDevice > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_resize_for_index' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_resize_for_index' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_GPUDevice_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  size_t arg2 ;
  GPUDevice *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GPUDevice_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_fill' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_fill' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_GPUDevice_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_GPUDevice,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_GPUDevice_fill" "', argument " "3"" of type '" "GPUDevice const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_GPUDevice_fill" "', argument " "3"" of type '" "GPUDevice const &""'"); 
  }
  arg3 = reinterpret_cast< GPUDevice * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(GPUDevice const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GPUDevice_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_pop_back' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_pop_back' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  SwigValueWrapper< std::function< bool (GPUDevice const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_removeIf' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_removeIf' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (GPUDevice const &) >>("rdcarray_of_GPUDevice_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  SwigValueWrapper< std::function< bool (GPUDevice const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_removeOneIf' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_removeOneIf' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (GPUDevice const &) >>("rdcarray_of_GPUDevice_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_append' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_append' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUDevice_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GPUDevice_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_clear' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_clear' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUDevice_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GPUDevice_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_insert' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_insert' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUDevice_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_GPUDevice_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_pop' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_pop' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUDevice_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_GPUDevice_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_sort' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_sort' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_GPUDevice_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUDevice_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GPUDevice_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_copy' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_copy' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUDevice_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GPUDevice_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_reverse' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_reverse' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUDevice_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_GPUDevice_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_index' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_index' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUDevice_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_count' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_count' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUDevice_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_extend' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_extend' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUDevice_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GPUDevice_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GPUDevice > *arg1 = (rdcarray< GPUDevice > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GPUDevice >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GPUDevice_remove' argument 1 of type 'rdcarray< GPUDevice >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GPUDevice_remove' argument 1 of type 'rdcarray< GPUDevice >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GPUDevice_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_GPUDevice) /* defines _wrap_delete_rdcarray_of_GPUDevice_destructor_closure */


PyObject *repr_rdcarray_of_GPUDevice(PyObject *self)
{
  rdcarray<GPUDevice> *thisptr = array_thisptr<rdcarray<GPUDevice>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_GPUDevice(PyObject *self, Py_ssize_t idx)
{
  rdcarray<GPUDevice> *thisptr = array_thisptr<rdcarray<GPUDevice>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_GPUDevice(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<GPUDevice> *thisptr = array_thisptr<rdcarray<GPUDevice>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_GPUDevice(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<GPUDevice> *thisptr = array_thisptr<rdcarray<GPUDevice>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_GPUDevice(PyObject *self, PyObject *idx)
{
  rdcarray<GPUDevice> *thisptr = array_thisptr<rdcarray<GPUDevice>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_GPUDevice(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<GPUDevice> *thisptr = array_thisptr<rdcarray<GPUDevice>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_GPUDevice(PyObject *self, PyObject *vals)
{
  rdcarray<GPUDevice> *thisptr = array_thisptr<rdcarray<GPUDevice>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_GPUDevice(PyObject *self, Py_ssize_t count)
{
  rdcarray<GPUDevice> *thisptr = array_thisptr<rdcarray<GPUDevice>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_GPUDevice(PyObject *self, PyObject *vals)
{
  rdcarray<GPUDevice> *thisptr = array_thisptr<rdcarray<GPUDevice>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_GPUDevice(PyObject *self, Py_ssize_t count)
{
  rdcarray<GPUDevice> *thisptr = array_thisptr<rdcarray<GPUDevice>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderConstantType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderConstantType",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderConstantType' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderConstantType' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  rdcarray< ShaderConstantType > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType___eq__' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType___eq__' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType___eq__' argument 2 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType___eq__' argument 2 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderConstantType > const *)arg1)->operator ==((rdcarray< ShaderConstantType > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  rdcarray< ShaderConstantType > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType___ne__' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType___ne__' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType___ne__' argument 2 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType___ne__' argument 2 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderConstantType > const *)arg1)->operator !=((rdcarray< ShaderConstantType > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  rdcarray< ShaderConstantType > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType___lt__' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType___lt__' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType___lt__' argument 2 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType___lt__' argument 2 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderConstantType > const *)arg1)->operator <((rdcarray< ShaderConstantType > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_resize_for_index' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_resize_for_index' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderConstantType_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  size_t arg2 ;
  ShaderConstantType *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderConstantType_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_fill' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_fill' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderConstantType_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ShaderConstantType,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ShaderConstantType_fill" "', argument " "3"" of type '" "ShaderConstantType const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ShaderConstantType_fill" "', argument " "3"" of type '" "ShaderConstantType const &""'"); 
  }
  arg3 = reinterpret_cast< ShaderConstantType * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderConstantType const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderConstantType_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_pop_back' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_pop_back' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderConstantType const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_removeIf' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_removeIf' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderConstantType const &) >>("rdcarray_of_ShaderConstantType_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderConstantType const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_removeOneIf' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_removeOneIf' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderConstantType const &) >>("rdcarray_of_ShaderConstantType_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_append' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_append' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstantType_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderConstantType_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_clear' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_clear' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstantType_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderConstantType_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_insert' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_insert' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstantType_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderConstantType_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_pop' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_pop' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstantType_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderConstantType_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_sort' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_sort' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderConstantType_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstantType_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderConstantType_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_copy' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_copy' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstantType_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderConstantType_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_reverse' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_reverse' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstantType_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderConstantType_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_index' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_index' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstantType_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_count' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_count' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstantType_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_extend' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_extend' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstantType_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderConstantType_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderConstantType > *arg1 = (rdcarray< ShaderConstantType > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderConstantType >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderConstantType_remove' argument 1 of type 'rdcarray< ShaderConstantType >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderConstantType_remove' argument 1 of type 'rdcarray< ShaderConstantType >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderConstantType_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderConstantType) /* defines _wrap_delete_rdcarray_of_ShaderConstantType_destructor_closure */


PyObject *repr_rdcarray_of_ShaderConstantType(PyObject *self)
{
  rdcarray<ShaderConstantType> *thisptr = array_thisptr<rdcarray<ShaderConstantType>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderConstantType(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderConstantType> *thisptr = array_thisptr<rdcarray<ShaderConstantType>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderConstantType(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderConstantType> *thisptr = array_thisptr<rdcarray<ShaderConstantType>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderConstantType(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderConstantType> *thisptr = array_thisptr<rdcarray<ShaderConstantType>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderConstantType(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderConstantType> *thisptr = array_thisptr<rdcarray<ShaderConstantType>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderConstantType(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderConstantType> *thisptr = array_thisptr<rdcarray<ShaderConstantType>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderConstantType(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderConstantType> *thisptr = array_thisptr<rdcarray<ShaderConstantType>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderConstantType(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderConstantType> *thisptr = array_thisptr<rdcarray<ShaderConstantType>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderConstantType(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderConstantType> *thisptr = array_thisptr<rdcarray<ShaderConstantType>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderConstantType(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderConstantType> *thisptr = array_thisptr<rdcarray<ShaderConstantType>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ShaderChangeStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ShaderChangeStats",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ShaderChangeStats' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ShaderChangeStats' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  rdcarray< ShaderChangeStats > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats___eq__' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats___eq__' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats___eq__' argument 2 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats___eq__' argument 2 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderChangeStats > const *)arg1)->operator ==((rdcarray< ShaderChangeStats > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  rdcarray< ShaderChangeStats > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats___ne__' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats___ne__' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats___ne__' argument 2 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats___ne__' argument 2 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderChangeStats > const *)arg1)->operator !=((rdcarray< ShaderChangeStats > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  rdcarray< ShaderChangeStats > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats___lt__' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats___lt__' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats___lt__' argument 2 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats___lt__' argument 2 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ShaderChangeStats > const *)arg1)->operator <((rdcarray< ShaderChangeStats > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_resize_for_index' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_resize_for_index' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderChangeStats_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  size_t arg2 ;
  ShaderChangeStats *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderChangeStats_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_fill' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_fill' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ShaderChangeStats_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ShaderChangeStats,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ShaderChangeStats_fill" "', argument " "3"" of type '" "ShaderChangeStats const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ShaderChangeStats_fill" "', argument " "3"" of type '" "ShaderChangeStats const &""'"); 
  }
  arg3 = reinterpret_cast< ShaderChangeStats * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ShaderChangeStats const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderChangeStats_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_pop_back' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_pop_back' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderChangeStats const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_removeIf' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_removeIf' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderChangeStats const &) >>("rdcarray_of_ShaderChangeStats_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  SwigValueWrapper< std::function< bool (ShaderChangeStats const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_removeOneIf' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_removeOneIf' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ShaderChangeStats const &) >>("rdcarray_of_ShaderChangeStats_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_append' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_append' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderChangeStats_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderChangeStats_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_clear' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_clear' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderChangeStats_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderChangeStats_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_insert' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_insert' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderChangeStats_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ShaderChangeStats_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_pop' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_pop' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderChangeStats_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ShaderChangeStats_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_sort' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_sort' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ShaderChangeStats_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderChangeStats_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderChangeStats_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_copy' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_copy' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderChangeStats_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ShaderChangeStats_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_reverse' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_reverse' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderChangeStats_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ShaderChangeStats_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_index' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_index' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderChangeStats_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_count' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_count' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderChangeStats_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_extend' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_extend' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderChangeStats_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ShaderChangeStats_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ShaderChangeStats > *arg1 = (rdcarray< ShaderChangeStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ShaderChangeStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ShaderChangeStats_remove' argument 1 of type 'rdcarray< ShaderChangeStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ShaderChangeStats_remove' argument 1 of type 'rdcarray< ShaderChangeStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ShaderChangeStats_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ShaderChangeStats) /* defines _wrap_delete_rdcarray_of_ShaderChangeStats_destructor_closure */


PyObject *repr_rdcarray_of_ShaderChangeStats(PyObject *self)
{
  rdcarray<ShaderChangeStats> *thisptr = array_thisptr<rdcarray<ShaderChangeStats>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ShaderChangeStats(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ShaderChangeStats> *thisptr = array_thisptr<rdcarray<ShaderChangeStats>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ShaderChangeStats(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderChangeStats> *thisptr = array_thisptr<rdcarray<ShaderChangeStats>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ShaderChangeStats(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ShaderChangeStats> *thisptr = array_thisptr<rdcarray<ShaderChangeStats>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ShaderChangeStats(PyObject *self, PyObject *idx)
{
  rdcarray<ShaderChangeStats> *thisptr = array_thisptr<rdcarray<ShaderChangeStats>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ShaderChangeStats(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ShaderChangeStats> *thisptr = array_thisptr<rdcarray<ShaderChangeStats>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ShaderChangeStats(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderChangeStats> *thisptr = array_thisptr<rdcarray<ShaderChangeStats>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ShaderChangeStats(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderChangeStats> *thisptr = array_thisptr<rdcarray<ShaderChangeStats>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ShaderChangeStats(PyObject *self, PyObject *vals)
{
  rdcarray<ShaderChangeStats> *thisptr = array_thisptr<rdcarray<ShaderChangeStats>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ShaderChangeStats(PyObject *self, Py_ssize_t count)
{
  rdcarray<ShaderChangeStats> *thisptr = array_thisptr<rdcarray<ShaderChangeStats>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ResourceBindStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ResourceBindStats",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ResourceBindStats' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ResourceBindStats' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  rdcarray< ResourceBindStats > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats___eq__' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats___eq__' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats___eq__' argument 2 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats___eq__' argument 2 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ResourceBindStats > const *)arg1)->operator ==((rdcarray< ResourceBindStats > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  rdcarray< ResourceBindStats > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats___ne__' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats___ne__' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats___ne__' argument 2 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats___ne__' argument 2 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ResourceBindStats > const *)arg1)->operator !=((rdcarray< ResourceBindStats > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  rdcarray< ResourceBindStats > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats___lt__' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats___lt__' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats___lt__' argument 2 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats___lt__' argument 2 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ResourceBindStats > const *)arg1)->operator <((rdcarray< ResourceBindStats > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_resize_for_index' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_resize_for_index' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ResourceBindStats_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  size_t arg2 ;
  ResourceBindStats *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceBindStats_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_fill' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_fill' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ResourceBindStats_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ResourceBindStats,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ResourceBindStats_fill" "', argument " "3"" of type '" "ResourceBindStats const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ResourceBindStats_fill" "', argument " "3"" of type '" "ResourceBindStats const &""'"); 
  }
  arg3 = reinterpret_cast< ResourceBindStats * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ResourceBindStats const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceBindStats_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_pop_back' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_pop_back' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  SwigValueWrapper< std::function< bool (ResourceBindStats const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_removeIf' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_removeIf' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ResourceBindStats const &) >>("rdcarray_of_ResourceBindStats_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  SwigValueWrapper< std::function< bool (ResourceBindStats const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_removeOneIf' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_removeOneIf' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ResourceBindStats const &) >>("rdcarray_of_ResourceBindStats_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_append' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_append' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceBindStats_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceBindStats_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_clear' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_clear' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceBindStats_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceBindStats_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_insert' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_insert' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceBindStats_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ResourceBindStats_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_pop' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_pop' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceBindStats_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ResourceBindStats_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_sort' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_sort' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ResourceBindStats_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceBindStats_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceBindStats_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_copy' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_copy' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceBindStats_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ResourceBindStats_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_reverse' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_reverse' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceBindStats_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ResourceBindStats_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_index' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_index' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceBindStats_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_count' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_count' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceBindStats_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_extend' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_extend' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceBindStats_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ResourceBindStats_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ResourceBindStats > *arg1 = (rdcarray< ResourceBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ResourceBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ResourceBindStats_remove' argument 1 of type 'rdcarray< ResourceBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ResourceBindStats_remove' argument 1 of type 'rdcarray< ResourceBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ResourceBindStats_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ResourceBindStats) /* defines _wrap_delete_rdcarray_of_ResourceBindStats_destructor_closure */


PyObject *repr_rdcarray_of_ResourceBindStats(PyObject *self)
{
  rdcarray<ResourceBindStats> *thisptr = array_thisptr<rdcarray<ResourceBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ResourceBindStats(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ResourceBindStats> *thisptr = array_thisptr<rdcarray<ResourceBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ResourceBindStats(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ResourceBindStats> *thisptr = array_thisptr<rdcarray<ResourceBindStats>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ResourceBindStats(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ResourceBindStats> *thisptr = array_thisptr<rdcarray<ResourceBindStats>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ResourceBindStats(PyObject *self, PyObject *idx)
{
  rdcarray<ResourceBindStats> *thisptr = array_thisptr<rdcarray<ResourceBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ResourceBindStats(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ResourceBindStats> *thisptr = array_thisptr<rdcarray<ResourceBindStats>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ResourceBindStats(PyObject *self, PyObject *vals)
{
  rdcarray<ResourceBindStats> *thisptr = array_thisptr<rdcarray<ResourceBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ResourceBindStats(PyObject *self, Py_ssize_t count)
{
  rdcarray<ResourceBindStats> *thisptr = array_thisptr<rdcarray<ResourceBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ResourceBindStats(PyObject *self, PyObject *vals)
{
  rdcarray<ResourceBindStats> *thisptr = array_thisptr<rdcarray<ResourceBindStats>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ResourceBindStats(PyObject *self, Py_ssize_t count)
{
  rdcarray<ResourceBindStats> *thisptr = array_thisptr<rdcarray<ResourceBindStats>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_SamplerBindStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_SamplerBindStats",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_SamplerBindStats' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_SamplerBindStats' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  rdcarray< SamplerBindStats > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats___eq__' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats___eq__' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats___eq__' argument 2 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats___eq__' argument 2 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< SamplerBindStats > const *)arg1)->operator ==((rdcarray< SamplerBindStats > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  rdcarray< SamplerBindStats > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats___ne__' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats___ne__' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats___ne__' argument 2 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats___ne__' argument 2 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< SamplerBindStats > const *)arg1)->operator !=((rdcarray< SamplerBindStats > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  rdcarray< SamplerBindStats > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats___lt__' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats___lt__' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats___lt__' argument 2 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats___lt__' argument 2 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< SamplerBindStats > const *)arg1)->operator <((rdcarray< SamplerBindStats > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_resize_for_index' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_resize_for_index' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_SamplerBindStats_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  size_t arg2 ;
  SamplerBindStats *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SamplerBindStats_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_fill' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_fill' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_SamplerBindStats_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_SamplerBindStats,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_SamplerBindStats_fill" "', argument " "3"" of type '" "SamplerBindStats const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_SamplerBindStats_fill" "', argument " "3"" of type '" "SamplerBindStats const &""'"); 
  }
  arg3 = reinterpret_cast< SamplerBindStats * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(SamplerBindStats const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SamplerBindStats_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_pop_back' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_pop_back' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  SwigValueWrapper< std::function< bool (SamplerBindStats const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_removeIf' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_removeIf' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (SamplerBindStats const &) >>("rdcarray_of_SamplerBindStats_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  SwigValueWrapper< std::function< bool (SamplerBindStats const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_removeOneIf' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_removeOneIf' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (SamplerBindStats const &) >>("rdcarray_of_SamplerBindStats_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_append' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_append' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerBindStats_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SamplerBindStats_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_clear' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_clear' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerBindStats_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SamplerBindStats_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_insert' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_insert' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerBindStats_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_SamplerBindStats_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_pop' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_pop' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerBindStats_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_SamplerBindStats_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_sort' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_sort' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_SamplerBindStats_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerBindStats_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SamplerBindStats_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_copy' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_copy' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerBindStats_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SamplerBindStats_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_reverse' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_reverse' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerBindStats_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_SamplerBindStats_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_index' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_index' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerBindStats_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_count' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_count' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerBindStats_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_extend' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_extend' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerBindStats_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerBindStats_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerBindStats > *arg1 = (rdcarray< SamplerBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerBindStats_remove' argument 1 of type 'rdcarray< SamplerBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerBindStats_remove' argument 1 of type 'rdcarray< SamplerBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerBindStats_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_SamplerBindStats) /* defines _wrap_delete_rdcarray_of_SamplerBindStats_destructor_closure */


PyObject *repr_rdcarray_of_SamplerBindStats(PyObject *self)
{
  rdcarray<SamplerBindStats> *thisptr = array_thisptr<rdcarray<SamplerBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_SamplerBindStats(PyObject *self, Py_ssize_t idx)
{
  rdcarray<SamplerBindStats> *thisptr = array_thisptr<rdcarray<SamplerBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_SamplerBindStats(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<SamplerBindStats> *thisptr = array_thisptr<rdcarray<SamplerBindStats>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_SamplerBindStats(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<SamplerBindStats> *thisptr = array_thisptr<rdcarray<SamplerBindStats>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_SamplerBindStats(PyObject *self, PyObject *idx)
{
  rdcarray<SamplerBindStats> *thisptr = array_thisptr<rdcarray<SamplerBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_SamplerBindStats(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<SamplerBindStats> *thisptr = array_thisptr<rdcarray<SamplerBindStats>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_SamplerBindStats(PyObject *self, PyObject *vals)
{
  rdcarray<SamplerBindStats> *thisptr = array_thisptr<rdcarray<SamplerBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_SamplerBindStats(PyObject *self, Py_ssize_t count)
{
  rdcarray<SamplerBindStats> *thisptr = array_thisptr<rdcarray<SamplerBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_SamplerBindStats(PyObject *self, PyObject *vals)
{
  rdcarray<SamplerBindStats> *thisptr = array_thisptr<rdcarray<SamplerBindStats>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_SamplerBindStats(PyObject *self, Py_ssize_t count)
{
  rdcarray<SamplerBindStats> *thisptr = array_thisptr<rdcarray<SamplerBindStats>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_ConstantBindStats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_ConstantBindStats",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_ConstantBindStats' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_ConstantBindStats' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  rdcarray< ConstantBindStats > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats___eq__' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats___eq__' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats___eq__' argument 2 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats___eq__' argument 2 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ConstantBindStats > const *)arg1)->operator ==((rdcarray< ConstantBindStats > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  rdcarray< ConstantBindStats > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats___ne__' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats___ne__' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats___ne__' argument 2 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats___ne__' argument 2 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ConstantBindStats > const *)arg1)->operator !=((rdcarray< ConstantBindStats > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  rdcarray< ConstantBindStats > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats___lt__' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats___lt__' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats___lt__' argument 2 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats___lt__' argument 2 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< ConstantBindStats > const *)arg1)->operator <((rdcarray< ConstantBindStats > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_resize_for_index' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_resize_for_index' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ConstantBindStats_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  size_t arg2 ;
  ConstantBindStats *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ConstantBindStats_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_fill' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_fill' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_ConstantBindStats_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_ConstantBindStats,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_ConstantBindStats_fill" "', argument " "3"" of type '" "ConstantBindStats const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_ConstantBindStats_fill" "', argument " "3"" of type '" "ConstantBindStats const &""'"); 
  }
  arg3 = reinterpret_cast< ConstantBindStats * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(ConstantBindStats const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ConstantBindStats_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_pop_back' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_pop_back' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  SwigValueWrapper< std::function< bool (ConstantBindStats const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_removeIf' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_removeIf' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ConstantBindStats const &) >>("rdcarray_of_ConstantBindStats_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  SwigValueWrapper< std::function< bool (ConstantBindStats const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_removeOneIf' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_removeOneIf' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (ConstantBindStats const &) >>("rdcarray_of_ConstantBindStats_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_append' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_append' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBindStats_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ConstantBindStats_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_clear' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_clear' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBindStats_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ConstantBindStats_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_insert' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_insert' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBindStats_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_ConstantBindStats_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_pop' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_pop' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBindStats_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_ConstantBindStats_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_sort' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_sort' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_ConstantBindStats_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBindStats_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ConstantBindStats_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_copy' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_copy' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBindStats_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_ConstantBindStats_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_reverse' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_reverse' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBindStats_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_ConstantBindStats_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_index' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_index' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBindStats_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_count' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_count' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBindStats_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_extend' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_extend' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBindStats_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_ConstantBindStats_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< ConstantBindStats > *arg1 = (rdcarray< ConstantBindStats > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< ConstantBindStats >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_ConstantBindStats_remove' argument 1 of type 'rdcarray< ConstantBindStats >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_ConstantBindStats_remove' argument 1 of type 'rdcarray< ConstantBindStats >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_ConstantBindStats_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_ConstantBindStats) /* defines _wrap_delete_rdcarray_of_ConstantBindStats_destructor_closure */


PyObject *repr_rdcarray_of_ConstantBindStats(PyObject *self)
{
  rdcarray<ConstantBindStats> *thisptr = array_thisptr<rdcarray<ConstantBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_ConstantBindStats(PyObject *self, Py_ssize_t idx)
{
  rdcarray<ConstantBindStats> *thisptr = array_thisptr<rdcarray<ConstantBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_ConstantBindStats(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ConstantBindStats> *thisptr = array_thisptr<rdcarray<ConstantBindStats>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_ConstantBindStats(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<ConstantBindStats> *thisptr = array_thisptr<rdcarray<ConstantBindStats>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_ConstantBindStats(PyObject *self, PyObject *idx)
{
  rdcarray<ConstantBindStats> *thisptr = array_thisptr<rdcarray<ConstantBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_ConstantBindStats(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<ConstantBindStats> *thisptr = array_thisptr<rdcarray<ConstantBindStats>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_ConstantBindStats(PyObject *self, PyObject *vals)
{
  rdcarray<ConstantBindStats> *thisptr = array_thisptr<rdcarray<ConstantBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_ConstantBindStats(PyObject *self, Py_ssize_t count)
{
  rdcarray<ConstantBindStats> *thisptr = array_thisptr<rdcarray<ConstantBindStats>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_ConstantBindStats(PyObject *self, PyObject *vals)
{
  rdcarray<ConstantBindStats> *thisptr = array_thisptr<rdcarray<ConstantBindStats>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_ConstantBindStats(PyObject *self, Py_ssize_t count)
{
  rdcarray<ConstantBindStats> *thisptr = array_thisptr<rdcarray<ConstantBindStats>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_DescriptorRange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_DescriptorRange",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_DescriptorRange' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_DescriptorRange' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  rdcarray< DescriptorRange > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange___eq__' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange___eq__' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange___eq__' argument 2 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange___eq__' argument 2 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DescriptorRange > const *)arg1)->operator ==((rdcarray< DescriptorRange > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  rdcarray< DescriptorRange > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange___ne__' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange___ne__' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange___ne__' argument 2 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange___ne__' argument 2 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DescriptorRange > const *)arg1)->operator !=((rdcarray< DescriptorRange > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  rdcarray< DescriptorRange > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange___lt__' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange___lt__' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange___lt__' argument 2 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange___lt__' argument 2 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DescriptorRange > const *)arg1)->operator <((rdcarray< DescriptorRange > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_resize_for_index' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_resize_for_index' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_DescriptorRange_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  size_t arg2 ;
  DescriptorRange *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorRange_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_fill' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_fill' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_DescriptorRange_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_DescriptorRange,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_DescriptorRange_fill" "', argument " "3"" of type '" "DescriptorRange const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_DescriptorRange_fill" "', argument " "3"" of type '" "DescriptorRange const &""'"); 
  }
  arg3 = reinterpret_cast< DescriptorRange * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(DescriptorRange const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorRange_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_pop_back' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_pop_back' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  SwigValueWrapper< std::function< bool (DescriptorRange const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_removeIf' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_removeIf' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (DescriptorRange const &) >>("rdcarray_of_DescriptorRange_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  SwigValueWrapper< std::function< bool (DescriptorRange const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_removeOneIf' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_removeOneIf' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (DescriptorRange const &) >>("rdcarray_of_DescriptorRange_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_append' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_append' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorRange_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorRange_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_clear' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_clear' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorRange_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorRange_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_insert' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_insert' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorRange_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_DescriptorRange_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_pop' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_pop' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorRange_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_DescriptorRange_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_sort' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_sort' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_DescriptorRange_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorRange_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorRange_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_copy' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_copy' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorRange_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorRange_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_reverse' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_reverse' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorRange_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_DescriptorRange_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_index' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_index' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorRange_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_count' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_count' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorRange_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_extend' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_extend' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorRange_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorRange_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorRange > *arg1 = (rdcarray< DescriptorRange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorRange_remove' argument 1 of type 'rdcarray< DescriptorRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorRange_remove' argument 1 of type 'rdcarray< DescriptorRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorRange_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_DescriptorRange) /* defines _wrap_delete_rdcarray_of_DescriptorRange_destructor_closure */


PyObject *repr_rdcarray_of_DescriptorRange(PyObject *self)
{
  rdcarray<DescriptorRange> *thisptr = array_thisptr<rdcarray<DescriptorRange>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_DescriptorRange(PyObject *self, Py_ssize_t idx)
{
  rdcarray<DescriptorRange> *thisptr = array_thisptr<rdcarray<DescriptorRange>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_DescriptorRange(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<DescriptorRange> *thisptr = array_thisptr<rdcarray<DescriptorRange>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_DescriptorRange(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<DescriptorRange> *thisptr = array_thisptr<rdcarray<DescriptorRange>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_DescriptorRange(PyObject *self, PyObject *idx)
{
  rdcarray<DescriptorRange> *thisptr = array_thisptr<rdcarray<DescriptorRange>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_DescriptorRange(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<DescriptorRange> *thisptr = array_thisptr<rdcarray<DescriptorRange>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_DescriptorRange(PyObject *self, PyObject *vals)
{
  rdcarray<DescriptorRange> *thisptr = array_thisptr<rdcarray<DescriptorRange>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_DescriptorRange(PyObject *self, Py_ssize_t count)
{
  rdcarray<DescriptorRange> *thisptr = array_thisptr<rdcarray<DescriptorRange>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_DescriptorRange(PyObject *self, PyObject *vals)
{
  rdcarray<DescriptorRange> *thisptr = array_thisptr<rdcarray<DescriptorRange>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_DescriptorRange(PyObject *self, Py_ssize_t count)
{
  rdcarray<DescriptorRange> *thisptr = array_thisptr<rdcarray<DescriptorRange>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_Descriptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_Descriptor",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_Descriptor' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_Descriptor' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  rdcarray< Descriptor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor___eq__' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor___eq__' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor___eq__' argument 2 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor___eq__' argument 2 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< Descriptor > const *)arg1)->operator ==((rdcarray< Descriptor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  rdcarray< Descriptor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor___ne__' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor___ne__' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor___ne__' argument 2 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor___ne__' argument 2 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< Descriptor > const *)arg1)->operator !=((rdcarray< Descriptor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  rdcarray< Descriptor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor___lt__' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor___lt__' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor___lt__' argument 2 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor___lt__' argument 2 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< Descriptor > const *)arg1)->operator <((rdcarray< Descriptor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_resize_for_index' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_resize_for_index' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_Descriptor_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  size_t arg2 ;
  Descriptor *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Descriptor_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_fill' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_fill' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_Descriptor_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_Descriptor,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_Descriptor_fill" "', argument " "3"" of type '" "Descriptor const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_Descriptor_fill" "', argument " "3"" of type '" "Descriptor const &""'"); 
  }
  arg3 = reinterpret_cast< Descriptor * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(Descriptor const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Descriptor_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_pop_back' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_pop_back' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  SwigValueWrapper< std::function< bool (Descriptor const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_removeIf' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_removeIf' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (Descriptor const &) >>("rdcarray_of_Descriptor_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  SwigValueWrapper< std::function< bool (Descriptor const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_removeOneIf' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_removeOneIf' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (Descriptor const &) >>("rdcarray_of_Descriptor_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_append' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_append' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Descriptor_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Descriptor_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_clear' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_clear' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Descriptor_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Descriptor_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_insert' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_insert' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Descriptor_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_Descriptor_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_pop' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_pop' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Descriptor_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_Descriptor_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_sort' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_sort' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_Descriptor_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Descriptor_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Descriptor_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_copy' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_copy' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Descriptor_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_Descriptor_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_reverse' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_reverse' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Descriptor_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_Descriptor_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_index' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_index' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Descriptor_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_count' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_count' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Descriptor_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_extend' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_extend' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Descriptor_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_Descriptor_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< Descriptor > *arg1 = (rdcarray< Descriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< Descriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_Descriptor_remove' argument 1 of type 'rdcarray< Descriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_Descriptor_remove' argument 1 of type 'rdcarray< Descriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_Descriptor_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_Descriptor) /* defines _wrap_delete_rdcarray_of_Descriptor_destructor_closure */


PyObject *repr_rdcarray_of_Descriptor(PyObject *self)
{
  rdcarray<Descriptor> *thisptr = array_thisptr<rdcarray<Descriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_Descriptor(PyObject *self, Py_ssize_t idx)
{
  rdcarray<Descriptor> *thisptr = array_thisptr<rdcarray<Descriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_Descriptor(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<Descriptor> *thisptr = array_thisptr<rdcarray<Descriptor>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_Descriptor(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<Descriptor> *thisptr = array_thisptr<rdcarray<Descriptor>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_Descriptor(PyObject *self, PyObject *idx)
{
  rdcarray<Descriptor> *thisptr = array_thisptr<rdcarray<Descriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_Descriptor(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<Descriptor> *thisptr = array_thisptr<rdcarray<Descriptor>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_Descriptor(PyObject *self, PyObject *vals)
{
  rdcarray<Descriptor> *thisptr = array_thisptr<rdcarray<Descriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_Descriptor(PyObject *self, Py_ssize_t count)
{
  rdcarray<Descriptor> *thisptr = array_thisptr<rdcarray<Descriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_Descriptor(PyObject *self, PyObject *vals)
{
  rdcarray<Descriptor> *thisptr = array_thisptr<rdcarray<Descriptor>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_Descriptor(PyObject *self, Py_ssize_t count)
{
  rdcarray<Descriptor> *thisptr = array_thisptr<rdcarray<Descriptor>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_SamplerDescriptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_SamplerDescriptor",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_SamplerDescriptor' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_SamplerDescriptor' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  rdcarray< SamplerDescriptor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor___eq__' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor___eq__' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor___eq__' argument 2 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor___eq__' argument 2 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< SamplerDescriptor > const *)arg1)->operator ==((rdcarray< SamplerDescriptor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  rdcarray< SamplerDescriptor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor___ne__' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor___ne__' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor___ne__' argument 2 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor___ne__' argument 2 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< SamplerDescriptor > const *)arg1)->operator !=((rdcarray< SamplerDescriptor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  rdcarray< SamplerDescriptor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor___lt__' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor___lt__' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor___lt__' argument 2 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor___lt__' argument 2 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< SamplerDescriptor > const *)arg1)->operator <((rdcarray< SamplerDescriptor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_resize_for_index' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_resize_for_index' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_SamplerDescriptor_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  size_t arg2 ;
  SamplerDescriptor *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SamplerDescriptor_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_fill' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_fill' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_SamplerDescriptor_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_SamplerDescriptor,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_SamplerDescriptor_fill" "', argument " "3"" of type '" "SamplerDescriptor const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_SamplerDescriptor_fill" "', argument " "3"" of type '" "SamplerDescriptor const &""'"); 
  }
  arg3 = reinterpret_cast< SamplerDescriptor * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(SamplerDescriptor const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SamplerDescriptor_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_pop_back' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_pop_back' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  SwigValueWrapper< std::function< bool (SamplerDescriptor const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_removeIf' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_removeIf' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (SamplerDescriptor const &) >>("rdcarray_of_SamplerDescriptor_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  SwigValueWrapper< std::function< bool (SamplerDescriptor const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_removeOneIf' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_removeOneIf' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (SamplerDescriptor const &) >>("rdcarray_of_SamplerDescriptor_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_append' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_append' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerDescriptor_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SamplerDescriptor_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_clear' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_clear' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerDescriptor_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SamplerDescriptor_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_insert' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_insert' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerDescriptor_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_SamplerDescriptor_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_pop' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_pop' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerDescriptor_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_SamplerDescriptor_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_sort' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_sort' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_SamplerDescriptor_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerDescriptor_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SamplerDescriptor_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_copy' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_copy' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerDescriptor_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_SamplerDescriptor_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_reverse' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_reverse' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerDescriptor_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_SamplerDescriptor_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_index' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_index' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerDescriptor_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_count' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_count' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerDescriptor_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_extend' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_extend' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerDescriptor_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_SamplerDescriptor_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< SamplerDescriptor > *arg1 = (rdcarray< SamplerDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< SamplerDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_SamplerDescriptor_remove' argument 1 of type 'rdcarray< SamplerDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_SamplerDescriptor_remove' argument 1 of type 'rdcarray< SamplerDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_SamplerDescriptor_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_SamplerDescriptor) /* defines _wrap_delete_rdcarray_of_SamplerDescriptor_destructor_closure */


PyObject *repr_rdcarray_of_SamplerDescriptor(PyObject *self)
{
  rdcarray<SamplerDescriptor> *thisptr = array_thisptr<rdcarray<SamplerDescriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_SamplerDescriptor(PyObject *self, Py_ssize_t idx)
{
  rdcarray<SamplerDescriptor> *thisptr = array_thisptr<rdcarray<SamplerDescriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_SamplerDescriptor(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<SamplerDescriptor> *thisptr = array_thisptr<rdcarray<SamplerDescriptor>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_SamplerDescriptor(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<SamplerDescriptor> *thisptr = array_thisptr<rdcarray<SamplerDescriptor>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_SamplerDescriptor(PyObject *self, PyObject *idx)
{
  rdcarray<SamplerDescriptor> *thisptr = array_thisptr<rdcarray<SamplerDescriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_SamplerDescriptor(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<SamplerDescriptor> *thisptr = array_thisptr<rdcarray<SamplerDescriptor>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_SamplerDescriptor(PyObject *self, PyObject *vals)
{
  rdcarray<SamplerDescriptor> *thisptr = array_thisptr<rdcarray<SamplerDescriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_SamplerDescriptor(PyObject *self, Py_ssize_t count)
{
  rdcarray<SamplerDescriptor> *thisptr = array_thisptr<rdcarray<SamplerDescriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_SamplerDescriptor(PyObject *self, PyObject *vals)
{
  rdcarray<SamplerDescriptor> *thisptr = array_thisptr<rdcarray<SamplerDescriptor>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_SamplerDescriptor(PyObject *self, Py_ssize_t count)
{
  rdcarray<SamplerDescriptor> *thisptr = array_thisptr<rdcarray<SamplerDescriptor>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_DescriptorAccess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_DescriptorAccess",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_DescriptorAccess' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_DescriptorAccess' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  rdcarray< DescriptorAccess > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess___eq__' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess___eq__' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess___eq__' argument 2 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess___eq__' argument 2 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DescriptorAccess > const *)arg1)->operator ==((rdcarray< DescriptorAccess > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  rdcarray< DescriptorAccess > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess___ne__' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess___ne__' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess___ne__' argument 2 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess___ne__' argument 2 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DescriptorAccess > const *)arg1)->operator !=((rdcarray< DescriptorAccess > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  rdcarray< DescriptorAccess > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess___lt__' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess___lt__' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess___lt__' argument 2 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess___lt__' argument 2 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DescriptorAccess > const *)arg1)->operator <((rdcarray< DescriptorAccess > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_resize_for_index' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_resize_for_index' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_DescriptorAccess_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  size_t arg2 ;
  DescriptorAccess *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorAccess_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_fill' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_fill' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_DescriptorAccess_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_DescriptorAccess,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_DescriptorAccess_fill" "', argument " "3"" of type '" "DescriptorAccess const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_DescriptorAccess_fill" "', argument " "3"" of type '" "DescriptorAccess const &""'"); 
  }
  arg3 = reinterpret_cast< DescriptorAccess * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(DescriptorAccess const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorAccess_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_pop_back' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_pop_back' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  SwigValueWrapper< std::function< bool (DescriptorAccess const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_removeIf' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_removeIf' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (DescriptorAccess const &) >>("rdcarray_of_DescriptorAccess_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  SwigValueWrapper< std::function< bool (DescriptorAccess const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_removeOneIf' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_removeOneIf' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (DescriptorAccess const &) >>("rdcarray_of_DescriptorAccess_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_append' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_append' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorAccess_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorAccess_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_clear' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_clear' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorAccess_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorAccess_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_insert' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_insert' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorAccess_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_DescriptorAccess_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_pop' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_pop' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorAccess_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_DescriptorAccess_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_sort' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_sort' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_DescriptorAccess_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorAccess_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorAccess_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_copy' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_copy' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorAccess_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorAccess_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_reverse' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_reverse' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorAccess_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_DescriptorAccess_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_index' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_index' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorAccess_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_count' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_count' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorAccess_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_extend' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_extend' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorAccess_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorAccess_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorAccess > *arg1 = (rdcarray< DescriptorAccess > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorAccess >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorAccess_remove' argument 1 of type 'rdcarray< DescriptorAccess >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorAccess_remove' argument 1 of type 'rdcarray< DescriptorAccess >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorAccess_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_DescriptorAccess) /* defines _wrap_delete_rdcarray_of_DescriptorAccess_destructor_closure */


PyObject *repr_rdcarray_of_DescriptorAccess(PyObject *self)
{
  rdcarray<DescriptorAccess> *thisptr = array_thisptr<rdcarray<DescriptorAccess>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_DescriptorAccess(PyObject *self, Py_ssize_t idx)
{
  rdcarray<DescriptorAccess> *thisptr = array_thisptr<rdcarray<DescriptorAccess>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_DescriptorAccess(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<DescriptorAccess> *thisptr = array_thisptr<rdcarray<DescriptorAccess>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_DescriptorAccess(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<DescriptorAccess> *thisptr = array_thisptr<rdcarray<DescriptorAccess>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_DescriptorAccess(PyObject *self, PyObject *idx)
{
  rdcarray<DescriptorAccess> *thisptr = array_thisptr<rdcarray<DescriptorAccess>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_DescriptorAccess(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<DescriptorAccess> *thisptr = array_thisptr<rdcarray<DescriptorAccess>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_DescriptorAccess(PyObject *self, PyObject *vals)
{
  rdcarray<DescriptorAccess> *thisptr = array_thisptr<rdcarray<DescriptorAccess>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_DescriptorAccess(PyObject *self, Py_ssize_t count)
{
  rdcarray<DescriptorAccess> *thisptr = array_thisptr<rdcarray<DescriptorAccess>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_DescriptorAccess(PyObject *self, PyObject *vals)
{
  rdcarray<DescriptorAccess> *thisptr = array_thisptr<rdcarray<DescriptorAccess>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_DescriptorAccess(PyObject *self, Py_ssize_t count)
{
  rdcarray<DescriptorAccess> *thisptr = array_thisptr<rdcarray<DescriptorAccess>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_DescriptorLogicalLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_DescriptorLogicalLocation",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_DescriptorLogicalLocation' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_DescriptorLogicalLocation' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  rdcarray< DescriptorLogicalLocation > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation___eq__' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation___eq__' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation___eq__' argument 2 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation___eq__' argument 2 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DescriptorLogicalLocation > const *)arg1)->operator ==((rdcarray< DescriptorLogicalLocation > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  rdcarray< DescriptorLogicalLocation > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation___ne__' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation___ne__' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation___ne__' argument 2 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation___ne__' argument 2 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DescriptorLogicalLocation > const *)arg1)->operator !=((rdcarray< DescriptorLogicalLocation > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  rdcarray< DescriptorLogicalLocation > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation___lt__' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation___lt__' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation___lt__' argument 2 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation___lt__' argument 2 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< DescriptorLogicalLocation > const *)arg1)->operator <((rdcarray< DescriptorLogicalLocation > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_resize_for_index' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_resize_for_index' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_DescriptorLogicalLocation_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  size_t arg2 ;
  DescriptorLogicalLocation *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorLogicalLocation_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_fill' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_fill' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_DescriptorLogicalLocation_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_DescriptorLogicalLocation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_DescriptorLogicalLocation_fill" "', argument " "3"" of type '" "DescriptorLogicalLocation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_DescriptorLogicalLocation_fill" "', argument " "3"" of type '" "DescriptorLogicalLocation const &""'"); 
  }
  arg3 = reinterpret_cast< DescriptorLogicalLocation * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(DescriptorLogicalLocation const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorLogicalLocation_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_pop_back' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_pop_back' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  SwigValueWrapper< std::function< bool (DescriptorLogicalLocation const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_removeIf' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_removeIf' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (DescriptorLogicalLocation const &) >>("rdcarray_of_DescriptorLogicalLocation_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  SwigValueWrapper< std::function< bool (DescriptorLogicalLocation const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_removeOneIf' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_removeOneIf' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (DescriptorLogicalLocation const &) >>("rdcarray_of_DescriptorLogicalLocation_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_append' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_append' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorLogicalLocation_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorLogicalLocation_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_clear' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_clear' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorLogicalLocation_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorLogicalLocation_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_insert' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_insert' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorLogicalLocation_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_DescriptorLogicalLocation_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_pop' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_pop' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorLogicalLocation_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_DescriptorLogicalLocation_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_sort' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_sort' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_DescriptorLogicalLocation_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorLogicalLocation_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorLogicalLocation_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_copy' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_copy' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorLogicalLocation_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_DescriptorLogicalLocation_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_reverse' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_reverse' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorLogicalLocation_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_DescriptorLogicalLocation_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_index' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_index' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorLogicalLocation_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_count' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_count' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorLogicalLocation_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_extend' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_extend' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorLogicalLocation_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_DescriptorLogicalLocation_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< DescriptorLogicalLocation > *arg1 = (rdcarray< DescriptorLogicalLocation > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< DescriptorLogicalLocation >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_DescriptorLogicalLocation_remove' argument 1 of type 'rdcarray< DescriptorLogicalLocation >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_DescriptorLogicalLocation_remove' argument 1 of type 'rdcarray< DescriptorLogicalLocation >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_DescriptorLogicalLocation_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_DescriptorLogicalLocation) /* defines _wrap_delete_rdcarray_of_DescriptorLogicalLocation_destructor_closure */


PyObject *repr_rdcarray_of_DescriptorLogicalLocation(PyObject *self)
{
  rdcarray<DescriptorLogicalLocation> *thisptr = array_thisptr<rdcarray<DescriptorLogicalLocation>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_DescriptorLogicalLocation(PyObject *self, Py_ssize_t idx)
{
  rdcarray<DescriptorLogicalLocation> *thisptr = array_thisptr<rdcarray<DescriptorLogicalLocation>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_DescriptorLogicalLocation(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<DescriptorLogicalLocation> *thisptr = array_thisptr<rdcarray<DescriptorLogicalLocation>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_DescriptorLogicalLocation(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<DescriptorLogicalLocation> *thisptr = array_thisptr<rdcarray<DescriptorLogicalLocation>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_DescriptorLogicalLocation(PyObject *self, PyObject *idx)
{
  rdcarray<DescriptorLogicalLocation> *thisptr = array_thisptr<rdcarray<DescriptorLogicalLocation>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_DescriptorLogicalLocation(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<DescriptorLogicalLocation> *thisptr = array_thisptr<rdcarray<DescriptorLogicalLocation>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_DescriptorLogicalLocation(PyObject *self, PyObject *vals)
{
  rdcarray<DescriptorLogicalLocation> *thisptr = array_thisptr<rdcarray<DescriptorLogicalLocation>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_DescriptorLogicalLocation(PyObject *self, Py_ssize_t count)
{
  rdcarray<DescriptorLogicalLocation> *thisptr = array_thisptr<rdcarray<DescriptorLogicalLocation>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_DescriptorLogicalLocation(PyObject *self, PyObject *vals)
{
  rdcarray<DescriptorLogicalLocation> *thisptr = array_thisptr<rdcarray<DescriptorLogicalLocation>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_DescriptorLogicalLocation(PyObject *self, Py_ssize_t count)
{
  rdcarray<DescriptorLogicalLocation> *thisptr = array_thisptr<rdcarray<DescriptorLogicalLocation>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_UsedDescriptor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_UsedDescriptor",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_UsedDescriptor' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_UsedDescriptor' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  rdcarray< UsedDescriptor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor___eq__' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor___eq__' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor___eq__' argument 2 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor___eq__' argument 2 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< UsedDescriptor > const *)arg1)->operator ==((rdcarray< UsedDescriptor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  rdcarray< UsedDescriptor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor___ne__' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor___ne__' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor___ne__' argument 2 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor___ne__' argument 2 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< UsedDescriptor > const *)arg1)->operator !=((rdcarray< UsedDescriptor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  rdcarray< UsedDescriptor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor___lt__' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor___lt__' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor___lt__' argument 2 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor___lt__' argument 2 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< UsedDescriptor > const *)arg1)->operator <((rdcarray< UsedDescriptor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_resize_for_index' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_resize_for_index' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_UsedDescriptor_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  size_t arg2 ;
  UsedDescriptor *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_UsedDescriptor_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_fill' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_fill' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_UsedDescriptor_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_UsedDescriptor,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_UsedDescriptor_fill" "', argument " "3"" of type '" "UsedDescriptor const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_UsedDescriptor_fill" "', argument " "3"" of type '" "UsedDescriptor const &""'"); 
  }
  arg3 = reinterpret_cast< UsedDescriptor * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(UsedDescriptor const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_UsedDescriptor_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_pop_back' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_pop_back' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  SwigValueWrapper< std::function< bool (UsedDescriptor const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_removeIf' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_removeIf' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (UsedDescriptor const &) >>("rdcarray_of_UsedDescriptor_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  SwigValueWrapper< std::function< bool (UsedDescriptor const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_removeOneIf' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_removeOneIf' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (UsedDescriptor const &) >>("rdcarray_of_UsedDescriptor_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_append' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_append' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_UsedDescriptor_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_UsedDescriptor_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_clear' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_clear' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_UsedDescriptor_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_UsedDescriptor_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_insert' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_insert' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_UsedDescriptor_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_UsedDescriptor_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_pop' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_pop' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_UsedDescriptor_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_UsedDescriptor_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_sort' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_sort' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_UsedDescriptor_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_UsedDescriptor_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_UsedDescriptor_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_copy' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_copy' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_UsedDescriptor_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_UsedDescriptor_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_reverse' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_reverse' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_UsedDescriptor_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_UsedDescriptor_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_index' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_index' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_UsedDescriptor_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_count' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_count' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_UsedDescriptor_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_extend' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_extend' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_UsedDescriptor_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_UsedDescriptor_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< UsedDescriptor > *arg1 = (rdcarray< UsedDescriptor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< UsedDescriptor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_UsedDescriptor_remove' argument 1 of type 'rdcarray< UsedDescriptor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_UsedDescriptor_remove' argument 1 of type 'rdcarray< UsedDescriptor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_UsedDescriptor_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_UsedDescriptor) /* defines _wrap_delete_rdcarray_of_UsedDescriptor_destructor_closure */


PyObject *repr_rdcarray_of_UsedDescriptor(PyObject *self)
{
  rdcarray<UsedDescriptor> *thisptr = array_thisptr<rdcarray<UsedDescriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_UsedDescriptor(PyObject *self, Py_ssize_t idx)
{
  rdcarray<UsedDescriptor> *thisptr = array_thisptr<rdcarray<UsedDescriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_UsedDescriptor(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<UsedDescriptor> *thisptr = array_thisptr<rdcarray<UsedDescriptor>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_UsedDescriptor(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<UsedDescriptor> *thisptr = array_thisptr<rdcarray<UsedDescriptor>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_UsedDescriptor(PyObject *self, PyObject *idx)
{
  rdcarray<UsedDescriptor> *thisptr = array_thisptr<rdcarray<UsedDescriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_UsedDescriptor(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<UsedDescriptor> *thisptr = array_thisptr<rdcarray<UsedDescriptor>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_UsedDescriptor(PyObject *self, PyObject *vals)
{
  rdcarray<UsedDescriptor> *thisptr = array_thisptr<rdcarray<UsedDescriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_UsedDescriptor(PyObject *self, Py_ssize_t count)
{
  rdcarray<UsedDescriptor> *thisptr = array_thisptr<rdcarray<UsedDescriptor>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_UsedDescriptor(PyObject *self, PyObject *vals)
{
  rdcarray<UsedDescriptor> *thisptr = array_thisptr<rdcarray<UsedDescriptor>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_UsedDescriptor(PyObject *self, Py_ssize_t count)
{
  rdcarray<UsedDescriptor> *thisptr = array_thisptr<rdcarray<UsedDescriptor>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_VKPipe_DynamicOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_VKPipe_DynamicOffset",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_VKPipe_DynamicOffset' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_VKPipe_DynamicOffset' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  rdcarray< VKPipe::DynamicOffset > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset___eq__' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset___eq__' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset___eq__' argument 2 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset___eq__' argument 2 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::DynamicOffset > const *)arg1)->operator ==((rdcarray< VKPipe::DynamicOffset > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  rdcarray< VKPipe::DynamicOffset > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset___ne__' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset___ne__' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset___ne__' argument 2 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset___ne__' argument 2 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::DynamicOffset > const *)arg1)->operator !=((rdcarray< VKPipe::DynamicOffset > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  rdcarray< VKPipe::DynamicOffset > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset___lt__' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset___lt__' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset___lt__' argument 2 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset___lt__' argument 2 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::DynamicOffset > const *)arg1)->operator <((rdcarray< VKPipe::DynamicOffset > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_resize_for_index' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_resize_for_index' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_DynamicOffset_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  size_t arg2 ;
  VKPipe::DynamicOffset *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DynamicOffset_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_fill' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_fill' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_DynamicOffset_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_VKPipe__DynamicOffset,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_VKPipe_DynamicOffset_fill" "', argument " "3"" of type '" "VKPipe::DynamicOffset const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_VKPipe_DynamicOffset_fill" "', argument " "3"" of type '" "VKPipe::DynamicOffset const &""'"); 
  }
  arg3 = reinterpret_cast< VKPipe::DynamicOffset * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(VKPipe::DynamicOffset const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DynamicOffset_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_pop_back' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_pop_back' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::DynamicOffset const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_removeIf' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_removeIf' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::DynamicOffset const &) >>("rdcarray_of_VKPipe_DynamicOffset_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::DynamicOffset const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_removeOneIf' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_removeOneIf' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::DynamicOffset const &) >>("rdcarray_of_VKPipe_DynamicOffset_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_append' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_append' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DynamicOffset_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DynamicOffset_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_clear' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_clear' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DynamicOffset_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DynamicOffset_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_insert' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_insert' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DynamicOffset_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_VKPipe_DynamicOffset_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_pop' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_pop' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DynamicOffset_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_VKPipe_DynamicOffset_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_sort' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_sort' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_VKPipe_DynamicOffset_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DynamicOffset_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DynamicOffset_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_copy' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_copy' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DynamicOffset_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DynamicOffset_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_reverse' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_reverse' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DynamicOffset_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_VKPipe_DynamicOffset_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_index' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_index' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DynamicOffset_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_count' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_count' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DynamicOffset_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_extend' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_extend' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DynamicOffset_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DynamicOffset_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DynamicOffset > *arg1 = (rdcarray< VKPipe::DynamicOffset > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DynamicOffset >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DynamicOffset_remove' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DynamicOffset_remove' argument 1 of type 'rdcarray< VKPipe::DynamicOffset >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DynamicOffset_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_VKPipe_DynamicOffset) /* defines _wrap_delete_rdcarray_of_VKPipe_DynamicOffset_destructor_closure */


PyObject *repr_rdcarray_of_VKPipe_DynamicOffset(PyObject *self)
{
  rdcarray<VKPipe::DynamicOffset> *thisptr = array_thisptr<rdcarray<VKPipe::DynamicOffset>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_VKPipe_DynamicOffset(PyObject *self, Py_ssize_t idx)
{
  rdcarray<VKPipe::DynamicOffset> *thisptr = array_thisptr<rdcarray<VKPipe::DynamicOffset>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_VKPipe_DynamicOffset(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::DynamicOffset> *thisptr = array_thisptr<rdcarray<VKPipe::DynamicOffset>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_VKPipe_DynamicOffset(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::DynamicOffset> *thisptr = array_thisptr<rdcarray<VKPipe::DynamicOffset>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_VKPipe_DynamicOffset(PyObject *self, PyObject *idx)
{
  rdcarray<VKPipe::DynamicOffset> *thisptr = array_thisptr<rdcarray<VKPipe::DynamicOffset>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_VKPipe_DynamicOffset(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<VKPipe::DynamicOffset> *thisptr = array_thisptr<rdcarray<VKPipe::DynamicOffset>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_VKPipe_DynamicOffset(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::DynamicOffset> *thisptr = array_thisptr<rdcarray<VKPipe::DynamicOffset>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_VKPipe_DynamicOffset(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::DynamicOffset> *thisptr = array_thisptr<rdcarray<VKPipe::DynamicOffset>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_VKPipe_DynamicOffset(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::DynamicOffset> *thisptr = array_thisptr<rdcarray<VKPipe::DynamicOffset>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_VKPipe_DynamicOffset(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::DynamicOffset> *thisptr = array_thisptr<rdcarray<VKPipe::DynamicOffset>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_VKPipe_DescriptorSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_VKPipe_DescriptorSet",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_VKPipe_DescriptorSet' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_VKPipe_DescriptorSet' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  rdcarray< VKPipe::DescriptorSet > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet___eq__' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet___eq__' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet___eq__' argument 2 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet___eq__' argument 2 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::DescriptorSet > const *)arg1)->operator ==((rdcarray< VKPipe::DescriptorSet > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  rdcarray< VKPipe::DescriptorSet > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet___ne__' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet___ne__' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet___ne__' argument 2 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet___ne__' argument 2 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::DescriptorSet > const *)arg1)->operator !=((rdcarray< VKPipe::DescriptorSet > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  rdcarray< VKPipe::DescriptorSet > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet___lt__' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet___lt__' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet___lt__' argument 2 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet___lt__' argument 2 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::DescriptorSet > const *)arg1)->operator <((rdcarray< VKPipe::DescriptorSet > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_resize_for_index' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_resize_for_index' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_DescriptorSet_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  size_t arg2 ;
  VKPipe::DescriptorSet *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DescriptorSet_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_fill' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_fill' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_DescriptorSet_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_VKPipe__DescriptorSet,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_VKPipe_DescriptorSet_fill" "', argument " "3"" of type '" "VKPipe::DescriptorSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_VKPipe_DescriptorSet_fill" "', argument " "3"" of type '" "VKPipe::DescriptorSet const &""'"); 
  }
  arg3 = reinterpret_cast< VKPipe::DescriptorSet * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(VKPipe::DescriptorSet const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DescriptorSet_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_pop_back' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_pop_back' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::DescriptorSet const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_removeIf' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_removeIf' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::DescriptorSet const &) >>("rdcarray_of_VKPipe_DescriptorSet_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::DescriptorSet const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_removeOneIf' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_removeOneIf' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::DescriptorSet const &) >>("rdcarray_of_VKPipe_DescriptorSet_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_append' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_append' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorSet_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DescriptorSet_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_clear' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_clear' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorSet_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DescriptorSet_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_insert' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_insert' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorSet_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_VKPipe_DescriptorSet_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_pop' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_pop' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorSet_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_VKPipe_DescriptorSet_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_sort' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_sort' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_VKPipe_DescriptorSet_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorSet_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DescriptorSet_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_copy' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_copy' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorSet_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DescriptorSet_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_reverse' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_reverse' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorSet_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_VKPipe_DescriptorSet_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_index' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_index' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorSet_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_count' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_count' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorSet_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_extend' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_extend' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorSet_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorSet_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorSet > *arg1 = (rdcarray< VKPipe::DescriptorSet > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorSet >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorSet_remove' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorSet_remove' argument 1 of type 'rdcarray< VKPipe::DescriptorSet >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorSet_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_VKPipe_DescriptorSet) /* defines _wrap_delete_rdcarray_of_VKPipe_DescriptorSet_destructor_closure */


PyObject *repr_rdcarray_of_VKPipe_DescriptorSet(PyObject *self)
{
  rdcarray<VKPipe::DescriptorSet> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorSet>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_VKPipe_DescriptorSet(PyObject *self, Py_ssize_t idx)
{
  rdcarray<VKPipe::DescriptorSet> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorSet>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_VKPipe_DescriptorSet(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::DescriptorSet> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorSet>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_VKPipe_DescriptorSet(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::DescriptorSet> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorSet>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_VKPipe_DescriptorSet(PyObject *self, PyObject *idx)
{
  rdcarray<VKPipe::DescriptorSet> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorSet>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_VKPipe_DescriptorSet(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<VKPipe::DescriptorSet> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorSet>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_VKPipe_DescriptorSet(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::DescriptorSet> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorSet>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_VKPipe_DescriptorSet(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::DescriptorSet> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorSet>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_VKPipe_DescriptorSet(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::DescriptorSet> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorSet>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_VKPipe_DescriptorSet(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::DescriptorSet> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorSet>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_VKPipe_DescriptorBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_VKPipe_DescriptorBuffer",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_VKPipe_DescriptorBuffer' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_VKPipe_DescriptorBuffer' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  rdcarray< VKPipe::DescriptorBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer___eq__' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer___eq__' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer___eq__' argument 2 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer___eq__' argument 2 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::DescriptorBuffer > const *)arg1)->operator ==((rdcarray< VKPipe::DescriptorBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  rdcarray< VKPipe::DescriptorBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer___ne__' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer___ne__' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer___ne__' argument 2 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer___ne__' argument 2 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::DescriptorBuffer > const *)arg1)->operator !=((rdcarray< VKPipe::DescriptorBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  rdcarray< VKPipe::DescriptorBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer___lt__' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer___lt__' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer___lt__' argument 2 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer___lt__' argument 2 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::DescriptorBuffer > const *)arg1)->operator <((rdcarray< VKPipe::DescriptorBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_resize_for_index' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_resize_for_index' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_DescriptorBuffer_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  size_t arg2 ;
  VKPipe::DescriptorBuffer *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DescriptorBuffer_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_fill' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_fill' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_DescriptorBuffer_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_VKPipe__DescriptorBuffer,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_VKPipe_DescriptorBuffer_fill" "', argument " "3"" of type '" "VKPipe::DescriptorBuffer const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_VKPipe_DescriptorBuffer_fill" "', argument " "3"" of type '" "VKPipe::DescriptorBuffer const &""'"); 
  }
  arg3 = reinterpret_cast< VKPipe::DescriptorBuffer * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(VKPipe::DescriptorBuffer const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DescriptorBuffer_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_pop_back' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_pop_back' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::DescriptorBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_removeIf' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_removeIf' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::DescriptorBuffer const &) >>("rdcarray_of_VKPipe_DescriptorBuffer_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::DescriptorBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_removeOneIf' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_removeOneIf' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::DescriptorBuffer const &) >>("rdcarray_of_VKPipe_DescriptorBuffer_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_append' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_append' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DescriptorBuffer_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_clear' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_clear' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DescriptorBuffer_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_insert' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_insert' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_VKPipe_DescriptorBuffer_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_pop' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_pop' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_VKPipe_DescriptorBuffer_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_sort' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_sort' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_VKPipe_DescriptorBuffer_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DescriptorBuffer_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_copy' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_copy' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_DescriptorBuffer_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_reverse' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_reverse' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_VKPipe_DescriptorBuffer_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_index' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_index' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_count' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_count' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_extend' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_extend' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_DescriptorBuffer_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::DescriptorBuffer > *arg1 = (rdcarray< VKPipe::DescriptorBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::DescriptorBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_DescriptorBuffer_remove' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_DescriptorBuffer_remove' argument 1 of type 'rdcarray< VKPipe::DescriptorBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_DescriptorBuffer_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_VKPipe_DescriptorBuffer) /* defines _wrap_delete_rdcarray_of_VKPipe_DescriptorBuffer_destructor_closure */


PyObject *repr_rdcarray_of_VKPipe_DescriptorBuffer(PyObject *self)
{
  rdcarray<VKPipe::DescriptorBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_VKPipe_DescriptorBuffer(PyObject *self, Py_ssize_t idx)
{
  rdcarray<VKPipe::DescriptorBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_VKPipe_DescriptorBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::DescriptorBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_VKPipe_DescriptorBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::DescriptorBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_VKPipe_DescriptorBuffer(PyObject *self, PyObject *idx)
{
  rdcarray<VKPipe::DescriptorBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_VKPipe_DescriptorBuffer(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<VKPipe::DescriptorBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_VKPipe_DescriptorBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::DescriptorBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_VKPipe_DescriptorBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::DescriptorBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_VKPipe_DescriptorBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::DescriptorBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_VKPipe_DescriptorBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::DescriptorBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::DescriptorBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_VKPipe_ImageData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_VKPipe_ImageData",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_VKPipe_ImageData' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_VKPipe_ImageData' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  rdcarray< VKPipe::ImageData > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData___eq__' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData___eq__' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData___eq__' argument 2 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData___eq__' argument 2 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::ImageData > const *)arg1)->operator ==((rdcarray< VKPipe::ImageData > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  rdcarray< VKPipe::ImageData > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData___ne__' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData___ne__' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData___ne__' argument 2 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData___ne__' argument 2 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::ImageData > const *)arg1)->operator !=((rdcarray< VKPipe::ImageData > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  rdcarray< VKPipe::ImageData > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData___lt__' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData___lt__' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData___lt__' argument 2 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData___lt__' argument 2 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::ImageData > const *)arg1)->operator <((rdcarray< VKPipe::ImageData > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_resize_for_index' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_resize_for_index' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_ImageData_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  size_t arg2 ;
  VKPipe::ImageData *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ImageData_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_fill' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_fill' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_ImageData_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_VKPipe__ImageData,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_VKPipe_ImageData_fill" "', argument " "3"" of type '" "VKPipe::ImageData const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_VKPipe_ImageData_fill" "', argument " "3"" of type '" "VKPipe::ImageData const &""'"); 
  }
  arg3 = reinterpret_cast< VKPipe::ImageData * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(VKPipe::ImageData const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ImageData_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_pop_back' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_pop_back' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::ImageData const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_removeIf' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_removeIf' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::ImageData const &) >>("rdcarray_of_VKPipe_ImageData_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::ImageData const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_removeOneIf' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_removeOneIf' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::ImageData const &) >>("rdcarray_of_VKPipe_ImageData_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_append' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_append' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageData_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ImageData_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_clear' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_clear' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageData_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ImageData_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_insert' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_insert' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageData_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_VKPipe_ImageData_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_pop' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_pop' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageData_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_VKPipe_ImageData_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_sort' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_sort' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_VKPipe_ImageData_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageData_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ImageData_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_copy' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_copy' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageData_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ImageData_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_reverse' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_reverse' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageData_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_VKPipe_ImageData_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_index' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_index' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageData_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_count' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_count' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageData_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_extend' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_extend' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageData_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageData_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageData > *arg1 = (rdcarray< VKPipe::ImageData > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageData_remove' argument 1 of type 'rdcarray< VKPipe::ImageData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageData_remove' argument 1 of type 'rdcarray< VKPipe::ImageData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageData_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_VKPipe_ImageData) /* defines _wrap_delete_rdcarray_of_VKPipe_ImageData_destructor_closure */


PyObject *repr_rdcarray_of_VKPipe_ImageData(PyObject *self)
{
  rdcarray<VKPipe::ImageData> *thisptr = array_thisptr<rdcarray<VKPipe::ImageData>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_VKPipe_ImageData(PyObject *self, Py_ssize_t idx)
{
  rdcarray<VKPipe::ImageData> *thisptr = array_thisptr<rdcarray<VKPipe::ImageData>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_VKPipe_ImageData(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::ImageData> *thisptr = array_thisptr<rdcarray<VKPipe::ImageData>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_VKPipe_ImageData(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::ImageData> *thisptr = array_thisptr<rdcarray<VKPipe::ImageData>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_VKPipe_ImageData(PyObject *self, PyObject *idx)
{
  rdcarray<VKPipe::ImageData> *thisptr = array_thisptr<rdcarray<VKPipe::ImageData>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_VKPipe_ImageData(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<VKPipe::ImageData> *thisptr = array_thisptr<rdcarray<VKPipe::ImageData>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_VKPipe_ImageData(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::ImageData> *thisptr = array_thisptr<rdcarray<VKPipe::ImageData>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_VKPipe_ImageData(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::ImageData> *thisptr = array_thisptr<rdcarray<VKPipe::ImageData>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_VKPipe_ImageData(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::ImageData> *thisptr = array_thisptr<rdcarray<VKPipe::ImageData>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_VKPipe_ImageData(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::ImageData> *thisptr = array_thisptr<rdcarray<VKPipe::ImageData>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_VKPipe_ImageLayout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_VKPipe_ImageLayout",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_VKPipe_ImageLayout' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_VKPipe_ImageLayout' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  rdcarray< VKPipe::ImageLayout > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout___eq__' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout___eq__' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout___eq__' argument 2 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout___eq__' argument 2 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::ImageLayout > const *)arg1)->operator ==((rdcarray< VKPipe::ImageLayout > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  rdcarray< VKPipe::ImageLayout > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout___ne__' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout___ne__' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout___ne__' argument 2 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout___ne__' argument 2 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::ImageLayout > const *)arg1)->operator !=((rdcarray< VKPipe::ImageLayout > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  rdcarray< VKPipe::ImageLayout > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout___lt__' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout___lt__' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout___lt__' argument 2 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout___lt__' argument 2 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::ImageLayout > const *)arg1)->operator <((rdcarray< VKPipe::ImageLayout > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_resize_for_index' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_resize_for_index' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_ImageLayout_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  size_t arg2 ;
  VKPipe::ImageLayout *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ImageLayout_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_fill' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_fill' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_ImageLayout_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_VKPipe__ImageLayout,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_VKPipe_ImageLayout_fill" "', argument " "3"" of type '" "VKPipe::ImageLayout const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_VKPipe_ImageLayout_fill" "', argument " "3"" of type '" "VKPipe::ImageLayout const &""'"); 
  }
  arg3 = reinterpret_cast< VKPipe::ImageLayout * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(VKPipe::ImageLayout const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ImageLayout_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_pop_back' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_pop_back' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::ImageLayout const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_removeIf' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_removeIf' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::ImageLayout const &) >>("rdcarray_of_VKPipe_ImageLayout_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::ImageLayout const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_removeOneIf' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_removeOneIf' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::ImageLayout const &) >>("rdcarray_of_VKPipe_ImageLayout_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_append' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_append' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageLayout_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ImageLayout_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_clear' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_clear' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageLayout_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ImageLayout_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_insert' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_insert' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageLayout_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_VKPipe_ImageLayout_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_pop' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_pop' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageLayout_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_VKPipe_ImageLayout_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_sort' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_sort' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_VKPipe_ImageLayout_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageLayout_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ImageLayout_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_copy' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_copy' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageLayout_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ImageLayout_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_reverse' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_reverse' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageLayout_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_VKPipe_ImageLayout_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_index' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_index' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageLayout_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_count' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_count' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageLayout_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_extend' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_extend' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageLayout_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ImageLayout_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ImageLayout > *arg1 = (rdcarray< VKPipe::ImageLayout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ImageLayout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ImageLayout_remove' argument 1 of type 'rdcarray< VKPipe::ImageLayout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ImageLayout_remove' argument 1 of type 'rdcarray< VKPipe::ImageLayout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ImageLayout_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_VKPipe_ImageLayout) /* defines _wrap_delete_rdcarray_of_VKPipe_ImageLayout_destructor_closure */


PyObject *repr_rdcarray_of_VKPipe_ImageLayout(PyObject *self)
{
  rdcarray<VKPipe::ImageLayout> *thisptr = array_thisptr<rdcarray<VKPipe::ImageLayout>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_VKPipe_ImageLayout(PyObject *self, Py_ssize_t idx)
{
  rdcarray<VKPipe::ImageLayout> *thisptr = array_thisptr<rdcarray<VKPipe::ImageLayout>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_VKPipe_ImageLayout(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::ImageLayout> *thisptr = array_thisptr<rdcarray<VKPipe::ImageLayout>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_VKPipe_ImageLayout(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::ImageLayout> *thisptr = array_thisptr<rdcarray<VKPipe::ImageLayout>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_VKPipe_ImageLayout(PyObject *self, PyObject *idx)
{
  rdcarray<VKPipe::ImageLayout> *thisptr = array_thisptr<rdcarray<VKPipe::ImageLayout>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_VKPipe_ImageLayout(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<VKPipe::ImageLayout> *thisptr = array_thisptr<rdcarray<VKPipe::ImageLayout>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_VKPipe_ImageLayout(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::ImageLayout> *thisptr = array_thisptr<rdcarray<VKPipe::ImageLayout>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_VKPipe_ImageLayout(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::ImageLayout> *thisptr = array_thisptr<rdcarray<VKPipe::ImageLayout>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_VKPipe_ImageLayout(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::ImageLayout> *thisptr = array_thisptr<rdcarray<VKPipe::ImageLayout>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_VKPipe_ImageLayout(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::ImageLayout> *thisptr = array_thisptr<rdcarray<VKPipe::ImageLayout>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_VKPipe_RenderArea(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_VKPipe_RenderArea",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_VKPipe_RenderArea' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_VKPipe_RenderArea' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  rdcarray< VKPipe::RenderArea > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea___eq__' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea___eq__' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea___eq__' argument 2 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea___eq__' argument 2 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::RenderArea > const *)arg1)->operator ==((rdcarray< VKPipe::RenderArea > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  rdcarray< VKPipe::RenderArea > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea___ne__' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea___ne__' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea___ne__' argument 2 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea___ne__' argument 2 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::RenderArea > const *)arg1)->operator !=((rdcarray< VKPipe::RenderArea > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  rdcarray< VKPipe::RenderArea > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea___lt__' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea___lt__' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea___lt__' argument 2 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea___lt__' argument 2 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::RenderArea > const *)arg1)->operator <((rdcarray< VKPipe::RenderArea > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_resize_for_index' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_resize_for_index' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_RenderArea_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  size_t arg2 ;
  VKPipe::RenderArea *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_RenderArea_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_fill' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_fill' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_RenderArea_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_VKPipe__RenderArea,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_VKPipe_RenderArea_fill" "', argument " "3"" of type '" "VKPipe::RenderArea const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_VKPipe_RenderArea_fill" "', argument " "3"" of type '" "VKPipe::RenderArea const &""'"); 
  }
  arg3 = reinterpret_cast< VKPipe::RenderArea * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(VKPipe::RenderArea const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_RenderArea_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_pop_back' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_pop_back' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::RenderArea const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_removeIf' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_removeIf' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::RenderArea const &) >>("rdcarray_of_VKPipe_RenderArea_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::RenderArea const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_removeOneIf' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_removeOneIf' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::RenderArea const &) >>("rdcarray_of_VKPipe_RenderArea_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_append' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_append' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_RenderArea_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_RenderArea_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_clear' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_clear' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_RenderArea_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_RenderArea_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_insert' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_insert' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_RenderArea_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_VKPipe_RenderArea_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_pop' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_pop' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_RenderArea_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_VKPipe_RenderArea_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_sort' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_sort' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_VKPipe_RenderArea_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_RenderArea_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_RenderArea_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_copy' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_copy' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_RenderArea_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_RenderArea_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_reverse' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_reverse' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_RenderArea_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_VKPipe_RenderArea_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_index' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_index' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_RenderArea_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_count' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_count' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_RenderArea_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_extend' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_extend' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_RenderArea_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_RenderArea_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::RenderArea > *arg1 = (rdcarray< VKPipe::RenderArea > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::RenderArea >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_RenderArea_remove' argument 1 of type 'rdcarray< VKPipe::RenderArea >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_RenderArea_remove' argument 1 of type 'rdcarray< VKPipe::RenderArea >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_RenderArea_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_VKPipe_RenderArea) /* defines _wrap_delete_rdcarray_of_VKPipe_RenderArea_destructor_closure */


PyObject *repr_rdcarray_of_VKPipe_RenderArea(PyObject *self)
{
  rdcarray<VKPipe::RenderArea> *thisptr = array_thisptr<rdcarray<VKPipe::RenderArea>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_VKPipe_RenderArea(PyObject *self, Py_ssize_t idx)
{
  rdcarray<VKPipe::RenderArea> *thisptr = array_thisptr<rdcarray<VKPipe::RenderArea>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_VKPipe_RenderArea(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::RenderArea> *thisptr = array_thisptr<rdcarray<VKPipe::RenderArea>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_VKPipe_RenderArea(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::RenderArea> *thisptr = array_thisptr<rdcarray<VKPipe::RenderArea>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_VKPipe_RenderArea(PyObject *self, PyObject *idx)
{
  rdcarray<VKPipe::RenderArea> *thisptr = array_thisptr<rdcarray<VKPipe::RenderArea>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_VKPipe_RenderArea(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<VKPipe::RenderArea> *thisptr = array_thisptr<rdcarray<VKPipe::RenderArea>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_VKPipe_RenderArea(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::RenderArea> *thisptr = array_thisptr<rdcarray<VKPipe::RenderArea>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_VKPipe_RenderArea(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::RenderArea> *thisptr = array_thisptr<rdcarray<VKPipe::RenderArea>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_VKPipe_RenderArea(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::RenderArea> *thisptr = array_thisptr<rdcarray<VKPipe::RenderArea>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_VKPipe_RenderArea(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::RenderArea> *thisptr = array_thisptr<rdcarray<VKPipe::RenderArea>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_VKPipe_XFBBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_VKPipe_XFBBuffer",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_VKPipe_XFBBuffer' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_VKPipe_XFBBuffer' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  rdcarray< VKPipe::XFBBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer___eq__' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer___eq__' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer___eq__' argument 2 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer___eq__' argument 2 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::XFBBuffer > const *)arg1)->operator ==((rdcarray< VKPipe::XFBBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  rdcarray< VKPipe::XFBBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer___ne__' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer___ne__' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer___ne__' argument 2 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer___ne__' argument 2 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::XFBBuffer > const *)arg1)->operator !=((rdcarray< VKPipe::XFBBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  rdcarray< VKPipe::XFBBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer___lt__' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer___lt__' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer___lt__' argument 2 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer___lt__' argument 2 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::XFBBuffer > const *)arg1)->operator <((rdcarray< VKPipe::XFBBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_resize_for_index' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_resize_for_index' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_XFBBuffer_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  size_t arg2 ;
  VKPipe::XFBBuffer *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_XFBBuffer_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_fill' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_fill' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_XFBBuffer_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_VKPipe__XFBBuffer,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_VKPipe_XFBBuffer_fill" "', argument " "3"" of type '" "VKPipe::XFBBuffer const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_VKPipe_XFBBuffer_fill" "', argument " "3"" of type '" "VKPipe::XFBBuffer const &""'"); 
  }
  arg3 = reinterpret_cast< VKPipe::XFBBuffer * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(VKPipe::XFBBuffer const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_XFBBuffer_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_pop_back' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_pop_back' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::XFBBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_removeIf' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_removeIf' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::XFBBuffer const &) >>("rdcarray_of_VKPipe_XFBBuffer_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::XFBBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_removeOneIf' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_removeOneIf' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::XFBBuffer const &) >>("rdcarray_of_VKPipe_XFBBuffer_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_append' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_append' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_XFBBuffer_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_XFBBuffer_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_clear' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_clear' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_XFBBuffer_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_XFBBuffer_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_insert' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_insert' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_XFBBuffer_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_VKPipe_XFBBuffer_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_pop' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_pop' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_XFBBuffer_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_VKPipe_XFBBuffer_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_sort' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_sort' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_VKPipe_XFBBuffer_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_XFBBuffer_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_XFBBuffer_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_copy' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_copy' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_XFBBuffer_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_XFBBuffer_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_reverse' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_reverse' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_XFBBuffer_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_VKPipe_XFBBuffer_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_index' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_index' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_XFBBuffer_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_count' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_count' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_XFBBuffer_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_extend' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_extend' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_XFBBuffer_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_XFBBuffer_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::XFBBuffer > *arg1 = (rdcarray< VKPipe::XFBBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::XFBBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_XFBBuffer_remove' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_XFBBuffer_remove' argument 1 of type 'rdcarray< VKPipe::XFBBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_XFBBuffer_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_VKPipe_XFBBuffer) /* defines _wrap_delete_rdcarray_of_VKPipe_XFBBuffer_destructor_closure */


PyObject *repr_rdcarray_of_VKPipe_XFBBuffer(PyObject *self)
{
  rdcarray<VKPipe::XFBBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::XFBBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_VKPipe_XFBBuffer(PyObject *self, Py_ssize_t idx)
{
  rdcarray<VKPipe::XFBBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::XFBBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_VKPipe_XFBBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::XFBBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::XFBBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_VKPipe_XFBBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::XFBBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::XFBBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_VKPipe_XFBBuffer(PyObject *self, PyObject *idx)
{
  rdcarray<VKPipe::XFBBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::XFBBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_VKPipe_XFBBuffer(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<VKPipe::XFBBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::XFBBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_VKPipe_XFBBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::XFBBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::XFBBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_VKPipe_XFBBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::XFBBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::XFBBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_VKPipe_XFBBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::XFBBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::XFBBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_VKPipe_XFBBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::XFBBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::XFBBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_VKPipe_VertexBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_VKPipe_VertexBuffer",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_VKPipe_VertexBuffer' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_VKPipe_VertexBuffer' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  rdcarray< VKPipe::VertexBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer___eq__' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer___eq__' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer___eq__' argument 2 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer___eq__' argument 2 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::VertexBuffer > const *)arg1)->operator ==((rdcarray< VKPipe::VertexBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  rdcarray< VKPipe::VertexBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer___ne__' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer___ne__' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer___ne__' argument 2 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer___ne__' argument 2 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::VertexBuffer > const *)arg1)->operator !=((rdcarray< VKPipe::VertexBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  rdcarray< VKPipe::VertexBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer___lt__' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer___lt__' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer___lt__' argument 2 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer___lt__' argument 2 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::VertexBuffer > const *)arg1)->operator <((rdcarray< VKPipe::VertexBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_resize_for_index' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_resize_for_index' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_VertexBuffer_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  size_t arg2 ;
  VKPipe::VertexBuffer *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexBuffer_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_fill' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_fill' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_VertexBuffer_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_VKPipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_VKPipe_VertexBuffer_fill" "', argument " "3"" of type '" "VKPipe::VertexBuffer const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_VKPipe_VertexBuffer_fill" "', argument " "3"" of type '" "VKPipe::VertexBuffer const &""'"); 
  }
  arg3 = reinterpret_cast< VKPipe::VertexBuffer * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(VKPipe::VertexBuffer const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexBuffer_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_pop_back' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_pop_back' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::VertexBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_removeIf' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_removeIf' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::VertexBuffer const &) >>("rdcarray_of_VKPipe_VertexBuffer_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::VertexBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_removeOneIf' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_removeOneIf' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::VertexBuffer const &) >>("rdcarray_of_VKPipe_VertexBuffer_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_append' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_append' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBuffer_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexBuffer_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_clear' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_clear' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBuffer_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexBuffer_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_insert' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_insert' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBuffer_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_VKPipe_VertexBuffer_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_pop' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_pop' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBuffer_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_VKPipe_VertexBuffer_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_sort' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_sort' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_VKPipe_VertexBuffer_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBuffer_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexBuffer_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_copy' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_copy' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBuffer_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexBuffer_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_reverse' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_reverse' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBuffer_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_VKPipe_VertexBuffer_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_index' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_index' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBuffer_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_count' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_count' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBuffer_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_extend' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_extend' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBuffer_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBuffer_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBuffer > *arg1 = (rdcarray< VKPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBuffer_remove' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBuffer_remove' argument 1 of type 'rdcarray< VKPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBuffer_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_VKPipe_VertexBuffer) /* defines _wrap_delete_rdcarray_of_VKPipe_VertexBuffer_destructor_closure */


PyObject *repr_rdcarray_of_VKPipe_VertexBuffer(PyObject *self)
{
  rdcarray<VKPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_VKPipe_VertexBuffer(PyObject *self, Py_ssize_t idx)
{
  rdcarray<VKPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_VKPipe_VertexBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_VKPipe_VertexBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_VKPipe_VertexBuffer(PyObject *self, PyObject *idx)
{
  rdcarray<VKPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_VKPipe_VertexBuffer(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<VKPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_VKPipe_VertexBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_VKPipe_VertexBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_VKPipe_VertexBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_VKPipe_VertexBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_VKPipe_VertexAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_VKPipe_VertexAttribute",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_VKPipe_VertexAttribute' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_VKPipe_VertexAttribute' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  rdcarray< VKPipe::VertexAttribute > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute___eq__' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute___eq__' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute___eq__' argument 2 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute___eq__' argument 2 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::VertexAttribute > const *)arg1)->operator ==((rdcarray< VKPipe::VertexAttribute > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  rdcarray< VKPipe::VertexAttribute > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute___ne__' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute___ne__' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute___ne__' argument 2 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute___ne__' argument 2 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::VertexAttribute > const *)arg1)->operator !=((rdcarray< VKPipe::VertexAttribute > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  rdcarray< VKPipe::VertexAttribute > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute___lt__' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute___lt__' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute___lt__' argument 2 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute___lt__' argument 2 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::VertexAttribute > const *)arg1)->operator <((rdcarray< VKPipe::VertexAttribute > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_resize_for_index' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_resize_for_index' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_VertexAttribute_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  size_t arg2 ;
  VKPipe::VertexAttribute *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexAttribute_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_fill' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_fill' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_VertexAttribute_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_VKPipe__VertexAttribute,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_VKPipe_VertexAttribute_fill" "', argument " "3"" of type '" "VKPipe::VertexAttribute const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_VKPipe_VertexAttribute_fill" "', argument " "3"" of type '" "VKPipe::VertexAttribute const &""'"); 
  }
  arg3 = reinterpret_cast< VKPipe::VertexAttribute * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(VKPipe::VertexAttribute const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexAttribute_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_pop_back' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_pop_back' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::VertexAttribute const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_removeIf' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_removeIf' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::VertexAttribute const &) >>("rdcarray_of_VKPipe_VertexAttribute_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::VertexAttribute const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_removeOneIf' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_removeOneIf' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::VertexAttribute const &) >>("rdcarray_of_VKPipe_VertexAttribute_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_append' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_append' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexAttribute_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexAttribute_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_clear' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_clear' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexAttribute_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexAttribute_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_insert' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_insert' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexAttribute_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_VKPipe_VertexAttribute_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_pop' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_pop' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexAttribute_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_VKPipe_VertexAttribute_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_sort' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_sort' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_VKPipe_VertexAttribute_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexAttribute_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexAttribute_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_copy' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_copy' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexAttribute_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexAttribute_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_reverse' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_reverse' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexAttribute_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_VKPipe_VertexAttribute_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_index' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_index' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexAttribute_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_count' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_count' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexAttribute_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_extend' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_extend' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexAttribute_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexAttribute_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexAttribute > *arg1 = (rdcarray< VKPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexAttribute_remove' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexAttribute_remove' argument 1 of type 'rdcarray< VKPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexAttribute_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_VKPipe_VertexAttribute) /* defines _wrap_delete_rdcarray_of_VKPipe_VertexAttribute_destructor_closure */


PyObject *repr_rdcarray_of_VKPipe_VertexAttribute(PyObject *self)
{
  rdcarray<VKPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<VKPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_VKPipe_VertexAttribute(PyObject *self, Py_ssize_t idx)
{
  rdcarray<VKPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<VKPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_VKPipe_VertexAttribute(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<VKPipe::VertexAttribute>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_VKPipe_VertexAttribute(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<VKPipe::VertexAttribute>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_VKPipe_VertexAttribute(PyObject *self, PyObject *idx)
{
  rdcarray<VKPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<VKPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_VKPipe_VertexAttribute(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<VKPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<VKPipe::VertexAttribute>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_VKPipe_VertexAttribute(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<VKPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_VKPipe_VertexAttribute(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<VKPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_VKPipe_VertexAttribute(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<VKPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_VKPipe_VertexAttribute(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<VKPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_VKPipe_VertexBinding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_VKPipe_VertexBinding",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_VKPipe_VertexBinding' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_VKPipe_VertexBinding' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  rdcarray< VKPipe::VertexBinding > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding___eq__' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding___eq__' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding___eq__' argument 2 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding___eq__' argument 2 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::VertexBinding > const *)arg1)->operator ==((rdcarray< VKPipe::VertexBinding > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  rdcarray< VKPipe::VertexBinding > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding___ne__' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding___ne__' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding___ne__' argument 2 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding___ne__' argument 2 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::VertexBinding > const *)arg1)->operator !=((rdcarray< VKPipe::VertexBinding > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  rdcarray< VKPipe::VertexBinding > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding___lt__' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding___lt__' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding___lt__' argument 2 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding___lt__' argument 2 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::VertexBinding > const *)arg1)->operator <((rdcarray< VKPipe::VertexBinding > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_resize_for_index' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_resize_for_index' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_VertexBinding_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  size_t arg2 ;
  VKPipe::VertexBinding *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexBinding_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_fill' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_fill' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_VertexBinding_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_VKPipe__VertexBinding,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_VKPipe_VertexBinding_fill" "', argument " "3"" of type '" "VKPipe::VertexBinding const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_VKPipe_VertexBinding_fill" "', argument " "3"" of type '" "VKPipe::VertexBinding const &""'"); 
  }
  arg3 = reinterpret_cast< VKPipe::VertexBinding * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(VKPipe::VertexBinding const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexBinding_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_pop_back' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_pop_back' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::VertexBinding const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_removeIf' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_removeIf' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::VertexBinding const &) >>("rdcarray_of_VKPipe_VertexBinding_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::VertexBinding const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_removeOneIf' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_removeOneIf' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::VertexBinding const &) >>("rdcarray_of_VKPipe_VertexBinding_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_append' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_append' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBinding_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexBinding_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_clear' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_clear' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBinding_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexBinding_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_insert' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_insert' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBinding_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_VKPipe_VertexBinding_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_pop' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_pop' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBinding_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_VKPipe_VertexBinding_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_sort' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_sort' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_VKPipe_VertexBinding_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBinding_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexBinding_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_copy' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_copy' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBinding_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_VertexBinding_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_reverse' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_reverse' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBinding_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_VKPipe_VertexBinding_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_index' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_index' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBinding_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_count' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_count' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBinding_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_extend' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_extend' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBinding_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_VertexBinding_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::VertexBinding > *arg1 = (rdcarray< VKPipe::VertexBinding > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::VertexBinding >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_VertexBinding_remove' argument 1 of type 'rdcarray< VKPipe::VertexBinding >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_VertexBinding_remove' argument 1 of type 'rdcarray< VKPipe::VertexBinding >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_VertexBinding_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_VKPipe_VertexBinding) /* defines _wrap_delete_rdcarray_of_VKPipe_VertexBinding_destructor_closure */


PyObject *repr_rdcarray_of_VKPipe_VertexBinding(PyObject *self)
{
  rdcarray<VKPipe::VertexBinding> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBinding>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_VKPipe_VertexBinding(PyObject *self, Py_ssize_t idx)
{
  rdcarray<VKPipe::VertexBinding> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBinding>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_VKPipe_VertexBinding(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::VertexBinding> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBinding>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_VKPipe_VertexBinding(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::VertexBinding> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBinding>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_VKPipe_VertexBinding(PyObject *self, PyObject *idx)
{
  rdcarray<VKPipe::VertexBinding> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBinding>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_VKPipe_VertexBinding(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<VKPipe::VertexBinding> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBinding>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_VKPipe_VertexBinding(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::VertexBinding> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBinding>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_VKPipe_VertexBinding(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::VertexBinding> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBinding>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_VKPipe_VertexBinding(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::VertexBinding> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBinding>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_VKPipe_VertexBinding(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::VertexBinding> *thisptr = array_thisptr<rdcarray<VKPipe::VertexBinding>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_VKPipe_ViewportScissor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_VKPipe_ViewportScissor",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_VKPipe_ViewportScissor' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_VKPipe_ViewportScissor' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  rdcarray< VKPipe::ViewportScissor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor___eq__' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor___eq__' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor___eq__' argument 2 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor___eq__' argument 2 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::ViewportScissor > const *)arg1)->operator ==((rdcarray< VKPipe::ViewportScissor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  rdcarray< VKPipe::ViewportScissor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor___ne__' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor___ne__' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor___ne__' argument 2 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor___ne__' argument 2 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::ViewportScissor > const *)arg1)->operator !=((rdcarray< VKPipe::ViewportScissor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  rdcarray< VKPipe::ViewportScissor > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor___lt__' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor___lt__' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor___lt__' argument 2 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor___lt__' argument 2 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< VKPipe::ViewportScissor > const *)arg1)->operator <((rdcarray< VKPipe::ViewportScissor > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_resize_for_index' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_resize_for_index' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_ViewportScissor_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  size_t arg2 ;
  VKPipe::ViewportScissor *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ViewportScissor_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_fill' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_fill' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_VKPipe_ViewportScissor_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_VKPipe__ViewportScissor,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_VKPipe_ViewportScissor_fill" "', argument " "3"" of type '" "VKPipe::ViewportScissor const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_VKPipe_ViewportScissor_fill" "', argument " "3"" of type '" "VKPipe::ViewportScissor const &""'"); 
  }
  arg3 = reinterpret_cast< VKPipe::ViewportScissor * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(VKPipe::ViewportScissor const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ViewportScissor_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_pop_back' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_pop_back' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::ViewportScissor const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_removeIf' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_removeIf' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::ViewportScissor const &) >>("rdcarray_of_VKPipe_ViewportScissor_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  SwigValueWrapper< std::function< bool (VKPipe::ViewportScissor const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_removeOneIf' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_removeOneIf' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (VKPipe::ViewportScissor const &) >>("rdcarray_of_VKPipe_ViewportScissor_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_append' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_append' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ViewportScissor_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ViewportScissor_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_clear' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_clear' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ViewportScissor_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ViewportScissor_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_insert' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_insert' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ViewportScissor_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_VKPipe_ViewportScissor_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_pop' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_pop' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ViewportScissor_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_VKPipe_ViewportScissor_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_sort' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_sort' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_VKPipe_ViewportScissor_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ViewportScissor_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ViewportScissor_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_copy' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_copy' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ViewportScissor_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_VKPipe_ViewportScissor_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_reverse' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_reverse' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ViewportScissor_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_VKPipe_ViewportScissor_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_index' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_index' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ViewportScissor_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_count' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_count' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ViewportScissor_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_extend' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_extend' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ViewportScissor_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_VKPipe_ViewportScissor_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< VKPipe::ViewportScissor > *arg1 = (rdcarray< VKPipe::ViewportScissor > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< VKPipe::ViewportScissor >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_VKPipe_ViewportScissor_remove' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_VKPipe_ViewportScissor_remove' argument 1 of type 'rdcarray< VKPipe::ViewportScissor >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_VKPipe_ViewportScissor_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_VKPipe_ViewportScissor) /* defines _wrap_delete_rdcarray_of_VKPipe_ViewportScissor_destructor_closure */


PyObject *repr_rdcarray_of_VKPipe_ViewportScissor(PyObject *self)
{
  rdcarray<VKPipe::ViewportScissor> *thisptr = array_thisptr<rdcarray<VKPipe::ViewportScissor>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_VKPipe_ViewportScissor(PyObject *self, Py_ssize_t idx)
{
  rdcarray<VKPipe::ViewportScissor> *thisptr = array_thisptr<rdcarray<VKPipe::ViewportScissor>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_VKPipe_ViewportScissor(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::ViewportScissor> *thisptr = array_thisptr<rdcarray<VKPipe::ViewportScissor>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_VKPipe_ViewportScissor(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<VKPipe::ViewportScissor> *thisptr = array_thisptr<rdcarray<VKPipe::ViewportScissor>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_VKPipe_ViewportScissor(PyObject *self, PyObject *idx)
{
  rdcarray<VKPipe::ViewportScissor> *thisptr = array_thisptr<rdcarray<VKPipe::ViewportScissor>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_VKPipe_ViewportScissor(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<VKPipe::ViewportScissor> *thisptr = array_thisptr<rdcarray<VKPipe::ViewportScissor>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_VKPipe_ViewportScissor(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::ViewportScissor> *thisptr = array_thisptr<rdcarray<VKPipe::ViewportScissor>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_VKPipe_ViewportScissor(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::ViewportScissor> *thisptr = array_thisptr<rdcarray<VKPipe::ViewportScissor>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_VKPipe_ViewportScissor(PyObject *self, PyObject *vals)
{
  rdcarray<VKPipe::ViewportScissor> *thisptr = array_thisptr<rdcarray<VKPipe::ViewportScissor>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_VKPipe_ViewportScissor(PyObject *self, Py_ssize_t count)
{
  rdcarray<VKPipe::ViewportScissor> *thisptr = array_thisptr<rdcarray<VKPipe::ViewportScissor>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_D3D11Pipe_Layout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_D3D11Pipe_Layout",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_D3D11Pipe_Layout' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_D3D11Pipe_Layout' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  rdcarray< D3D11Pipe::Layout > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout___eq__' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout___eq__' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout___eq__' argument 2 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout___eq__' argument 2 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D11Pipe::Layout > const *)arg1)->operator ==((rdcarray< D3D11Pipe::Layout > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  rdcarray< D3D11Pipe::Layout > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout___ne__' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout___ne__' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout___ne__' argument 2 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout___ne__' argument 2 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D11Pipe::Layout > const *)arg1)->operator !=((rdcarray< D3D11Pipe::Layout > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  rdcarray< D3D11Pipe::Layout > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout___lt__' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout___lt__' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout___lt__' argument 2 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout___lt__' argument 2 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D11Pipe::Layout > const *)arg1)->operator <((rdcarray< D3D11Pipe::Layout > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_resize_for_index' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_resize_for_index' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D11Pipe_Layout_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  size_t arg2 ;
  D3D11Pipe::Layout *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_Layout_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_fill' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_fill' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D11Pipe_Layout_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_D3D11Pipe__Layout,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_D3D11Pipe_Layout_fill" "', argument " "3"" of type '" "D3D11Pipe::Layout const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_D3D11Pipe_Layout_fill" "', argument " "3"" of type '" "D3D11Pipe::Layout const &""'"); 
  }
  arg3 = reinterpret_cast< D3D11Pipe::Layout * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(D3D11Pipe::Layout const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_Layout_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_pop_back' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_pop_back' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D11Pipe::Layout const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_removeIf' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_removeIf' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D11Pipe::Layout const &) >>("rdcarray_of_D3D11Pipe_Layout_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D11Pipe::Layout const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_removeOneIf' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_removeOneIf' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D11Pipe::Layout const &) >>("rdcarray_of_D3D11Pipe_Layout_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_append' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_append' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_Layout_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_Layout_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_clear' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_clear' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_Layout_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_Layout_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_insert' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_insert' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_Layout_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_D3D11Pipe_Layout_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_pop' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_pop' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_Layout_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_D3D11Pipe_Layout_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_sort' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_sort' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_D3D11Pipe_Layout_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_Layout_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_Layout_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_copy' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_copy' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_Layout_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_Layout_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_reverse' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_reverse' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_Layout_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_D3D11Pipe_Layout_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_index' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_index' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_Layout_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_count' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_count' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_Layout_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_extend' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_extend' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_Layout_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_Layout_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::Layout > *arg1 = (rdcarray< D3D11Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_Layout_remove' argument 1 of type 'rdcarray< D3D11Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_Layout_remove' argument 1 of type 'rdcarray< D3D11Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_Layout_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_D3D11Pipe_Layout) /* defines _wrap_delete_rdcarray_of_D3D11Pipe_Layout_destructor_closure */


PyObject *repr_rdcarray_of_D3D11Pipe_Layout(PyObject *self)
{
  rdcarray<D3D11Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D11Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_D3D11Pipe_Layout(PyObject *self, Py_ssize_t idx)
{
  rdcarray<D3D11Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D11Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_D3D11Pipe_Layout(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D11Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D11Pipe::Layout>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_D3D11Pipe_Layout(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D11Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D11Pipe::Layout>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_D3D11Pipe_Layout(PyObject *self, PyObject *idx)
{
  rdcarray<D3D11Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D11Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_D3D11Pipe_Layout(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<D3D11Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D11Pipe::Layout>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_D3D11Pipe_Layout(PyObject *self, PyObject *vals)
{
  rdcarray<D3D11Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D11Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_D3D11Pipe_Layout(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D11Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D11Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_D3D11Pipe_Layout(PyObject *self, PyObject *vals)
{
  rdcarray<D3D11Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D11Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_D3D11Pipe_Layout(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D11Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D11Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_D3D11Pipe_StreamOutBind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_D3D11Pipe_StreamOutBind",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_D3D11Pipe_StreamOutBind' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_D3D11Pipe_StreamOutBind' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  rdcarray< D3D11Pipe::StreamOutBind > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind___eq__' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind___eq__' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind___eq__' argument 2 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind___eq__' argument 2 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D11Pipe::StreamOutBind > const *)arg1)->operator ==((rdcarray< D3D11Pipe::StreamOutBind > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  rdcarray< D3D11Pipe::StreamOutBind > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind___ne__' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind___ne__' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind___ne__' argument 2 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind___ne__' argument 2 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D11Pipe::StreamOutBind > const *)arg1)->operator !=((rdcarray< D3D11Pipe::StreamOutBind > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  rdcarray< D3D11Pipe::StreamOutBind > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind___lt__' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind___lt__' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind___lt__' argument 2 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind___lt__' argument 2 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D11Pipe::StreamOutBind > const *)arg1)->operator <((rdcarray< D3D11Pipe::StreamOutBind > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_resize_for_index' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_resize_for_index' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D11Pipe_StreamOutBind_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  size_t arg2 ;
  D3D11Pipe::StreamOutBind *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_StreamOutBind_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_fill' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_fill' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D11Pipe_StreamOutBind_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_D3D11Pipe__StreamOutBind,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_D3D11Pipe_StreamOutBind_fill" "', argument " "3"" of type '" "D3D11Pipe::StreamOutBind const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_D3D11Pipe_StreamOutBind_fill" "', argument " "3"" of type '" "D3D11Pipe::StreamOutBind const &""'"); 
  }
  arg3 = reinterpret_cast< D3D11Pipe::StreamOutBind * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(D3D11Pipe::StreamOutBind const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_StreamOutBind_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_pop_back' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_pop_back' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D11Pipe::StreamOutBind const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_removeIf' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_removeIf' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D11Pipe::StreamOutBind const &) >>("rdcarray_of_D3D11Pipe_StreamOutBind_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D11Pipe::StreamOutBind const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_removeOneIf' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_removeOneIf' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D11Pipe::StreamOutBind const &) >>("rdcarray_of_D3D11Pipe_StreamOutBind_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_append' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_append' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_StreamOutBind_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_clear' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_clear' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_StreamOutBind_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_insert' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_insert' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_D3D11Pipe_StreamOutBind_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_pop' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_pop' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_D3D11Pipe_StreamOutBind_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_sort' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_sort' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_D3D11Pipe_StreamOutBind_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_StreamOutBind_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_copy' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_copy' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_StreamOutBind_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_reverse' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_reverse' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_D3D11Pipe_StreamOutBind_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_index' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_index' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_count' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_count' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_extend' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_extend' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_StreamOutBind_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::StreamOutBind > *arg1 = (rdcarray< D3D11Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_remove' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_StreamOutBind_remove' argument 1 of type 'rdcarray< D3D11Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_StreamOutBind_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_D3D11Pipe_StreamOutBind) /* defines _wrap_delete_rdcarray_of_D3D11Pipe_StreamOutBind_destructor_closure */


PyObject *repr_rdcarray_of_D3D11Pipe_StreamOutBind(PyObject *self)
{
  rdcarray<D3D11Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D11Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_D3D11Pipe_StreamOutBind(PyObject *self, Py_ssize_t idx)
{
  rdcarray<D3D11Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D11Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_D3D11Pipe_StreamOutBind(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D11Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D11Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_D3D11Pipe_StreamOutBind(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D11Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D11Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_D3D11Pipe_StreamOutBind(PyObject *self, PyObject *idx)
{
  rdcarray<D3D11Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D11Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_D3D11Pipe_StreamOutBind(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<D3D11Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D11Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_D3D11Pipe_StreamOutBind(PyObject *self, PyObject *vals)
{
  rdcarray<D3D11Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D11Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_D3D11Pipe_StreamOutBind(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D11Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D11Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_D3D11Pipe_StreamOutBind(PyObject *self, PyObject *vals)
{
  rdcarray<D3D11Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D11Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_D3D11Pipe_StreamOutBind(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D11Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D11Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_D3D11Pipe_VertexBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_D3D11Pipe_VertexBuffer",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_D3D11Pipe_VertexBuffer' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_D3D11Pipe_VertexBuffer' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  rdcarray< D3D11Pipe::VertexBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer___eq__' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer___eq__' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer___eq__' argument 2 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer___eq__' argument 2 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D11Pipe::VertexBuffer > const *)arg1)->operator ==((rdcarray< D3D11Pipe::VertexBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  rdcarray< D3D11Pipe::VertexBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer___ne__' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer___ne__' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer___ne__' argument 2 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer___ne__' argument 2 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D11Pipe::VertexBuffer > const *)arg1)->operator !=((rdcarray< D3D11Pipe::VertexBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  rdcarray< D3D11Pipe::VertexBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer___lt__' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer___lt__' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer___lt__' argument 2 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer___lt__' argument 2 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D11Pipe::VertexBuffer > const *)arg1)->operator <((rdcarray< D3D11Pipe::VertexBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_resize_for_index' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_resize_for_index' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D11Pipe_VertexBuffer_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  size_t arg2 ;
  D3D11Pipe::VertexBuffer *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_VertexBuffer_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_fill' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_fill' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D11Pipe_VertexBuffer_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_D3D11Pipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_D3D11Pipe_VertexBuffer_fill" "', argument " "3"" of type '" "D3D11Pipe::VertexBuffer const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_D3D11Pipe_VertexBuffer_fill" "', argument " "3"" of type '" "D3D11Pipe::VertexBuffer const &""'"); 
  }
  arg3 = reinterpret_cast< D3D11Pipe::VertexBuffer * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(D3D11Pipe::VertexBuffer const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_VertexBuffer_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_pop_back' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_pop_back' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D11Pipe::VertexBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_removeIf' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_removeIf' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D11Pipe::VertexBuffer const &) >>("rdcarray_of_D3D11Pipe_VertexBuffer_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D11Pipe::VertexBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_removeOneIf' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_removeOneIf' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D11Pipe::VertexBuffer const &) >>("rdcarray_of_D3D11Pipe_VertexBuffer_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_append' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_append' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_VertexBuffer_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_clear' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_clear' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_VertexBuffer_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_insert' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_insert' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_D3D11Pipe_VertexBuffer_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_pop' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_pop' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_D3D11Pipe_VertexBuffer_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_sort' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_sort' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_D3D11Pipe_VertexBuffer_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_VertexBuffer_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_copy' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_copy' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D11Pipe_VertexBuffer_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_reverse' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_reverse' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_D3D11Pipe_VertexBuffer_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_index' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_index' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_count' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_count' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_extend' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_extend' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D11Pipe_VertexBuffer_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D11Pipe::VertexBuffer > *arg1 = (rdcarray< D3D11Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D11Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_remove' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D11Pipe_VertexBuffer_remove' argument 1 of type 'rdcarray< D3D11Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D11Pipe_VertexBuffer_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_D3D11Pipe_VertexBuffer) /* defines _wrap_delete_rdcarray_of_D3D11Pipe_VertexBuffer_destructor_closure */


PyObject *repr_rdcarray_of_D3D11Pipe_VertexBuffer(PyObject *self)
{
  rdcarray<D3D11Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D11Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_D3D11Pipe_VertexBuffer(PyObject *self, Py_ssize_t idx)
{
  rdcarray<D3D11Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D11Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_D3D11Pipe_VertexBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D11Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D11Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_D3D11Pipe_VertexBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D11Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D11Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_D3D11Pipe_VertexBuffer(PyObject *self, PyObject *idx)
{
  rdcarray<D3D11Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D11Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_D3D11Pipe_VertexBuffer(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<D3D11Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D11Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_D3D11Pipe_VertexBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<D3D11Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D11Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_D3D11Pipe_VertexBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D11Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D11Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_D3D11Pipe_VertexBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<D3D11Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D11Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_D3D11Pipe_VertexBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D11Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D11Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_D3D12Pipe_Layout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_D3D12Pipe_Layout",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_D3D12Pipe_Layout' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_D3D12Pipe_Layout' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  rdcarray< D3D12Pipe::Layout > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout___eq__' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout___eq__' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout___eq__' argument 2 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout___eq__' argument 2 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::Layout > const *)arg1)->operator ==((rdcarray< D3D12Pipe::Layout > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  rdcarray< D3D12Pipe::Layout > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout___ne__' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout___ne__' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout___ne__' argument 2 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout___ne__' argument 2 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::Layout > const *)arg1)->operator !=((rdcarray< D3D12Pipe::Layout > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  rdcarray< D3D12Pipe::Layout > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout___lt__' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout___lt__' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout___lt__' argument 2 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout___lt__' argument 2 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::Layout > const *)arg1)->operator <((rdcarray< D3D12Pipe::Layout > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_Layout_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  size_t arg2 ;
  D3D12Pipe::Layout *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_Layout_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_fill' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_fill' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_Layout_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_D3D12Pipe__Layout,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_D3D12Pipe_Layout_fill" "', argument " "3"" of type '" "D3D12Pipe::Layout const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_D3D12Pipe_Layout_fill" "', argument " "3"" of type '" "D3D12Pipe::Layout const &""'"); 
  }
  arg3 = reinterpret_cast< D3D12Pipe::Layout * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(D3D12Pipe::Layout const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_Layout_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::Layout const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::Layout const &) >>("rdcarray_of_D3D12Pipe_Layout_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::Layout const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::Layout const &) >>("rdcarray_of_D3D12Pipe_Layout_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_append' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_append' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_Layout_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_Layout_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_clear' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_clear' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_Layout_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_Layout_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_insert' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_insert' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_Layout_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_D3D12Pipe_Layout_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_pop' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_pop' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_Layout_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_D3D12Pipe_Layout_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_sort' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_sort' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_D3D12Pipe_Layout_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_Layout_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_Layout_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_copy' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_copy' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_Layout_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_Layout_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_reverse' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_reverse' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_Layout_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_D3D12Pipe_Layout_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_index' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_index' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_Layout_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_count' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_count' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_Layout_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_extend' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_extend' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_Layout_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_Layout_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::Layout > *arg1 = (rdcarray< D3D12Pipe::Layout > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::Layout >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_Layout_remove' argument 1 of type 'rdcarray< D3D12Pipe::Layout >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_Layout_remove' argument 1 of type 'rdcarray< D3D12Pipe::Layout >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_Layout_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_D3D12Pipe_Layout) /* defines _wrap_delete_rdcarray_of_D3D12Pipe_Layout_destructor_closure */


PyObject *repr_rdcarray_of_D3D12Pipe_Layout(PyObject *self)
{
  rdcarray<D3D12Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D12Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_D3D12Pipe_Layout(PyObject *self, Py_ssize_t idx)
{
  rdcarray<D3D12Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D12Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_D3D12Pipe_Layout(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D12Pipe::Layout>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_D3D12Pipe_Layout(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D12Pipe::Layout>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_D3D12Pipe_Layout(PyObject *self, PyObject *idx)
{
  rdcarray<D3D12Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D12Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_D3D12Pipe_Layout(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<D3D12Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D12Pipe::Layout>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_D3D12Pipe_Layout(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D12Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_D3D12Pipe_Layout(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D12Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_D3D12Pipe_Layout(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D12Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_D3D12Pipe_Layout(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::Layout> *thisptr = array_thisptr<rdcarray<D3D12Pipe::Layout>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_D3D12Pipe_ResourceData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_D3D12Pipe_ResourceData",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_D3D12Pipe_ResourceData' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_D3D12Pipe_ResourceData' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  rdcarray< D3D12Pipe::ResourceData > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData___eq__' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData___eq__' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData___eq__' argument 2 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData___eq__' argument 2 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::ResourceData > const *)arg1)->operator ==((rdcarray< D3D12Pipe::ResourceData > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  rdcarray< D3D12Pipe::ResourceData > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData___ne__' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData___ne__' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData___ne__' argument 2 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData___ne__' argument 2 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::ResourceData > const *)arg1)->operator !=((rdcarray< D3D12Pipe::ResourceData > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  rdcarray< D3D12Pipe::ResourceData > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData___lt__' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData___lt__' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData___lt__' argument 2 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData___lt__' argument 2 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::ResourceData > const *)arg1)->operator <((rdcarray< D3D12Pipe::ResourceData > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_ResourceData_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  size_t arg2 ;
  D3D12Pipe::ResourceData *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_ResourceData_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_fill' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_fill' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_ResourceData_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_D3D12Pipe__ResourceData,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_D3D12Pipe_ResourceData_fill" "', argument " "3"" of type '" "D3D12Pipe::ResourceData const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_D3D12Pipe_ResourceData_fill" "', argument " "3"" of type '" "D3D12Pipe::ResourceData const &""'"); 
  }
  arg3 = reinterpret_cast< D3D12Pipe::ResourceData * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(D3D12Pipe::ResourceData const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_ResourceData_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::ResourceData const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::ResourceData const &) >>("rdcarray_of_D3D12Pipe_ResourceData_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::ResourceData const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::ResourceData const &) >>("rdcarray_of_D3D12Pipe_ResourceData_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_append' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_append' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceData_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_ResourceData_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_clear' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_clear' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceData_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_ResourceData_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_insert' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_insert' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceData_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_D3D12Pipe_ResourceData_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_pop' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_pop' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceData_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_D3D12Pipe_ResourceData_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_sort' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_sort' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_D3D12Pipe_ResourceData_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceData_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_ResourceData_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_copy' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_copy' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceData_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_ResourceData_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_reverse' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_reverse' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceData_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_D3D12Pipe_ResourceData_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_index' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_index' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceData_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_count' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_count' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceData_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_extend' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_extend' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceData_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceData_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceData > *arg1 = (rdcarray< D3D12Pipe::ResourceData > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceData >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceData_remove' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceData_remove' argument 1 of type 'rdcarray< D3D12Pipe::ResourceData >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceData_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_D3D12Pipe_ResourceData) /* defines _wrap_delete_rdcarray_of_D3D12Pipe_ResourceData_destructor_closure */


PyObject *repr_rdcarray_of_D3D12Pipe_ResourceData(PyObject *self)
{
  rdcarray<D3D12Pipe::ResourceData> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceData>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_D3D12Pipe_ResourceData(PyObject *self, Py_ssize_t idx)
{
  rdcarray<D3D12Pipe::ResourceData> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceData>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_D3D12Pipe_ResourceData(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::ResourceData> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceData>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_D3D12Pipe_ResourceData(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::ResourceData> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceData>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_D3D12Pipe_ResourceData(PyObject *self, PyObject *idx)
{
  rdcarray<D3D12Pipe::ResourceData> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceData>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_D3D12Pipe_ResourceData(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<D3D12Pipe::ResourceData> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceData>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_D3D12Pipe_ResourceData(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::ResourceData> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceData>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_D3D12Pipe_ResourceData(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::ResourceData> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceData>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_D3D12Pipe_ResourceData(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::ResourceData> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceData>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_D3D12Pipe_ResourceData(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::ResourceData> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceData>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_D3D12Pipe_ResourceState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_D3D12Pipe_ResourceState",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_D3D12Pipe_ResourceState' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_D3D12Pipe_ResourceState' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  rdcarray< D3D12Pipe::ResourceState > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState___eq__' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState___eq__' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState___eq__' argument 2 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState___eq__' argument 2 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::ResourceState > const *)arg1)->operator ==((rdcarray< D3D12Pipe::ResourceState > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  rdcarray< D3D12Pipe::ResourceState > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState___ne__' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState___ne__' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState___ne__' argument 2 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState___ne__' argument 2 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::ResourceState > const *)arg1)->operator !=((rdcarray< D3D12Pipe::ResourceState > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  rdcarray< D3D12Pipe::ResourceState > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState___lt__' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState___lt__' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState___lt__' argument 2 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState___lt__' argument 2 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::ResourceState > const *)arg1)->operator <((rdcarray< D3D12Pipe::ResourceState > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_ResourceState_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  size_t arg2 ;
  D3D12Pipe::ResourceState *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_ResourceState_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_fill' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_fill' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_ResourceState_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_D3D12Pipe__ResourceState,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_D3D12Pipe_ResourceState_fill" "', argument " "3"" of type '" "D3D12Pipe::ResourceState const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_D3D12Pipe_ResourceState_fill" "', argument " "3"" of type '" "D3D12Pipe::ResourceState const &""'"); 
  }
  arg3 = reinterpret_cast< D3D12Pipe::ResourceState * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(D3D12Pipe::ResourceState const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_ResourceState_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::ResourceState const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::ResourceState const &) >>("rdcarray_of_D3D12Pipe_ResourceState_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::ResourceState const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::ResourceState const &) >>("rdcarray_of_D3D12Pipe_ResourceState_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_append' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_append' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceState_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_ResourceState_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_clear' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_clear' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceState_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_ResourceState_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_insert' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_insert' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceState_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_D3D12Pipe_ResourceState_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_pop' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_pop' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceState_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_D3D12Pipe_ResourceState_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_sort' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_sort' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_D3D12Pipe_ResourceState_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceState_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_ResourceState_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_copy' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_copy' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceState_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_ResourceState_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_reverse' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_reverse' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceState_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_D3D12Pipe_ResourceState_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_index' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_index' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceState_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_count' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_count' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceState_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_extend' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_extend' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceState_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_ResourceState_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::ResourceState > *arg1 = (rdcarray< D3D12Pipe::ResourceState > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::ResourceState >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_ResourceState_remove' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_ResourceState_remove' argument 1 of type 'rdcarray< D3D12Pipe::ResourceState >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_ResourceState_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_D3D12Pipe_ResourceState) /* defines _wrap_delete_rdcarray_of_D3D12Pipe_ResourceState_destructor_closure */


PyObject *repr_rdcarray_of_D3D12Pipe_ResourceState(PyObject *self)
{
  rdcarray<D3D12Pipe::ResourceState> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceState>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_D3D12Pipe_ResourceState(PyObject *self, Py_ssize_t idx)
{
  rdcarray<D3D12Pipe::ResourceState> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceState>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_D3D12Pipe_ResourceState(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::ResourceState> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceState>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_D3D12Pipe_ResourceState(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::ResourceState> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceState>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_D3D12Pipe_ResourceState(PyObject *self, PyObject *idx)
{
  rdcarray<D3D12Pipe::ResourceState> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceState>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_D3D12Pipe_ResourceState(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<D3D12Pipe::ResourceState> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceState>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_D3D12Pipe_ResourceState(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::ResourceState> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceState>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_D3D12Pipe_ResourceState(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::ResourceState> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceState>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_D3D12Pipe_ResourceState(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::ResourceState> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceState>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_D3D12Pipe_ResourceState(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::ResourceState> *thisptr = array_thisptr<rdcarray<D3D12Pipe::ResourceState>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_D3D12Pipe_StreamOutBind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_D3D12Pipe_StreamOutBind",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_D3D12Pipe_StreamOutBind' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_D3D12Pipe_StreamOutBind' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  rdcarray< D3D12Pipe::StreamOutBind > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind___eq__' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind___eq__' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind___eq__' argument 2 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind___eq__' argument 2 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::StreamOutBind > const *)arg1)->operator ==((rdcarray< D3D12Pipe::StreamOutBind > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  rdcarray< D3D12Pipe::StreamOutBind > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind___ne__' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind___ne__' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind___ne__' argument 2 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind___ne__' argument 2 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::StreamOutBind > const *)arg1)->operator !=((rdcarray< D3D12Pipe::StreamOutBind > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  rdcarray< D3D12Pipe::StreamOutBind > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind___lt__' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind___lt__' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind___lt__' argument 2 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind___lt__' argument 2 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::StreamOutBind > const *)arg1)->operator <((rdcarray< D3D12Pipe::StreamOutBind > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_StreamOutBind_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  size_t arg2 ;
  D3D12Pipe::StreamOutBind *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_StreamOutBind_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_fill' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_fill' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_StreamOutBind_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_D3D12Pipe__StreamOutBind,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_D3D12Pipe_StreamOutBind_fill" "', argument " "3"" of type '" "D3D12Pipe::StreamOutBind const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_D3D12Pipe_StreamOutBind_fill" "', argument " "3"" of type '" "D3D12Pipe::StreamOutBind const &""'"); 
  }
  arg3 = reinterpret_cast< D3D12Pipe::StreamOutBind * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(D3D12Pipe::StreamOutBind const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_StreamOutBind_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::StreamOutBind const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::StreamOutBind const &) >>("rdcarray_of_D3D12Pipe_StreamOutBind_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::StreamOutBind const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::StreamOutBind const &) >>("rdcarray_of_D3D12Pipe_StreamOutBind_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_append' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_append' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_StreamOutBind_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_clear' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_clear' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_StreamOutBind_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_insert' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_insert' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_D3D12Pipe_StreamOutBind_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_pop' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_pop' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_D3D12Pipe_StreamOutBind_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_sort' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_sort' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_D3D12Pipe_StreamOutBind_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_StreamOutBind_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_copy' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_copy' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_StreamOutBind_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_reverse' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_reverse' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_D3D12Pipe_StreamOutBind_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_index' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_index' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_count' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_count' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_extend' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_extend' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StreamOutBind_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StreamOutBind > *arg1 = (rdcarray< D3D12Pipe::StreamOutBind > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StreamOutBind >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_remove' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StreamOutBind_remove' argument 1 of type 'rdcarray< D3D12Pipe::StreamOutBind >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StreamOutBind_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_D3D12Pipe_StreamOutBind) /* defines _wrap_delete_rdcarray_of_D3D12Pipe_StreamOutBind_destructor_closure */


PyObject *repr_rdcarray_of_D3D12Pipe_StreamOutBind(PyObject *self)
{
  rdcarray<D3D12Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_D3D12Pipe_StreamOutBind(PyObject *self, Py_ssize_t idx)
{
  rdcarray<D3D12Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_D3D12Pipe_StreamOutBind(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_D3D12Pipe_StreamOutBind(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_D3D12Pipe_StreamOutBind(PyObject *self, PyObject *idx)
{
  rdcarray<D3D12Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_D3D12Pipe_StreamOutBind(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<D3D12Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_D3D12Pipe_StreamOutBind(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_D3D12Pipe_StreamOutBind(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_D3D12Pipe_StreamOutBind(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_D3D12Pipe_StreamOutBind(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::StreamOutBind> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StreamOutBind>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_D3D12Pipe_VertexBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_D3D12Pipe_VertexBuffer",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_D3D12Pipe_VertexBuffer' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_D3D12Pipe_VertexBuffer' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  rdcarray< D3D12Pipe::VertexBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer___eq__' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer___eq__' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer___eq__' argument 2 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer___eq__' argument 2 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::VertexBuffer > const *)arg1)->operator ==((rdcarray< D3D12Pipe::VertexBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  rdcarray< D3D12Pipe::VertexBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer___ne__' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer___ne__' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer___ne__' argument 2 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer___ne__' argument 2 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::VertexBuffer > const *)arg1)->operator !=((rdcarray< D3D12Pipe::VertexBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  rdcarray< D3D12Pipe::VertexBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer___lt__' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer___lt__' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer___lt__' argument 2 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer___lt__' argument 2 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::VertexBuffer > const *)arg1)->operator <((rdcarray< D3D12Pipe::VertexBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_VertexBuffer_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  size_t arg2 ;
  D3D12Pipe::VertexBuffer *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_VertexBuffer_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_fill' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_fill' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_VertexBuffer_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_D3D12Pipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_D3D12Pipe_VertexBuffer_fill" "', argument " "3"" of type '" "D3D12Pipe::VertexBuffer const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_D3D12Pipe_VertexBuffer_fill" "', argument " "3"" of type '" "D3D12Pipe::VertexBuffer const &""'"); 
  }
  arg3 = reinterpret_cast< D3D12Pipe::VertexBuffer * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(D3D12Pipe::VertexBuffer const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_VertexBuffer_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::VertexBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::VertexBuffer const &) >>("rdcarray_of_D3D12Pipe_VertexBuffer_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::VertexBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::VertexBuffer const &) >>("rdcarray_of_D3D12Pipe_VertexBuffer_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_append' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_append' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_VertexBuffer_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_clear' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_clear' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_VertexBuffer_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_insert' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_insert' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_D3D12Pipe_VertexBuffer_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_pop' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_pop' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_D3D12Pipe_VertexBuffer_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_sort' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_sort' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_D3D12Pipe_VertexBuffer_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_VertexBuffer_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_copy' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_copy' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_VertexBuffer_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_reverse' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_reverse' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_D3D12Pipe_VertexBuffer_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_index' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_index' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_count' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_count' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_extend' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_extend' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_VertexBuffer_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::VertexBuffer > *arg1 = (rdcarray< D3D12Pipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_remove' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_VertexBuffer_remove' argument 1 of type 'rdcarray< D3D12Pipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_VertexBuffer_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_D3D12Pipe_VertexBuffer) /* defines _wrap_delete_rdcarray_of_D3D12Pipe_VertexBuffer_destructor_closure */


PyObject *repr_rdcarray_of_D3D12Pipe_VertexBuffer(PyObject *self)
{
  rdcarray<D3D12Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D12Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_D3D12Pipe_VertexBuffer(PyObject *self, Py_ssize_t idx)
{
  rdcarray<D3D12Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D12Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_D3D12Pipe_VertexBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D12Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_D3D12Pipe_VertexBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D12Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_D3D12Pipe_VertexBuffer(PyObject *self, PyObject *idx)
{
  rdcarray<D3D12Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D12Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_D3D12Pipe_VertexBuffer(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<D3D12Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D12Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_D3D12Pipe_VertexBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D12Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_D3D12Pipe_VertexBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D12Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_D3D12Pipe_VertexBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D12Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_D3D12Pipe_VertexBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<D3D12Pipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_D3D12Pipe_RootTableRange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_D3D12Pipe_RootTableRange",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_D3D12Pipe_RootTableRange' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_D3D12Pipe_RootTableRange' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  rdcarray< D3D12Pipe::RootTableRange > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange___eq__' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange___eq__' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange___eq__' argument 2 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange___eq__' argument 2 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::RootTableRange > const *)arg1)->operator ==((rdcarray< D3D12Pipe::RootTableRange > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  rdcarray< D3D12Pipe::RootTableRange > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange___ne__' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange___ne__' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange___ne__' argument 2 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange___ne__' argument 2 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::RootTableRange > const *)arg1)->operator !=((rdcarray< D3D12Pipe::RootTableRange > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  rdcarray< D3D12Pipe::RootTableRange > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange___lt__' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange___lt__' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange___lt__' argument 2 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange___lt__' argument 2 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::RootTableRange > const *)arg1)->operator <((rdcarray< D3D12Pipe::RootTableRange > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_RootTableRange_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  size_t arg2 ;
  D3D12Pipe::RootTableRange *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_RootTableRange_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_fill' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_fill' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_RootTableRange_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_D3D12Pipe__RootTableRange,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_D3D12Pipe_RootTableRange_fill" "', argument " "3"" of type '" "D3D12Pipe::RootTableRange const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_D3D12Pipe_RootTableRange_fill" "', argument " "3"" of type '" "D3D12Pipe::RootTableRange const &""'"); 
  }
  arg3 = reinterpret_cast< D3D12Pipe::RootTableRange * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(D3D12Pipe::RootTableRange const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_RootTableRange_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::RootTableRange const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::RootTableRange const &) >>("rdcarray_of_D3D12Pipe_RootTableRange_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::RootTableRange const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::RootTableRange const &) >>("rdcarray_of_D3D12Pipe_RootTableRange_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_append' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_append' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_RootTableRange_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_clear' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_clear' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_RootTableRange_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_insert' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_insert' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_D3D12Pipe_RootTableRange_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_pop' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_pop' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_D3D12Pipe_RootTableRange_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_sort' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_sort' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_D3D12Pipe_RootTableRange_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_RootTableRange_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_copy' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_copy' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_RootTableRange_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_reverse' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_reverse' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_D3D12Pipe_RootTableRange_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_index' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_index' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_count' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_count' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_extend' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_extend' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootTableRange_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootTableRange > *arg1 = (rdcarray< D3D12Pipe::RootTableRange > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootTableRange >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootTableRange_remove' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootTableRange_remove' argument 1 of type 'rdcarray< D3D12Pipe::RootTableRange >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootTableRange_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_D3D12Pipe_RootTableRange) /* defines _wrap_delete_rdcarray_of_D3D12Pipe_RootTableRange_destructor_closure */


PyObject *repr_rdcarray_of_D3D12Pipe_RootTableRange(PyObject *self)
{
  rdcarray<D3D12Pipe::RootTableRange> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootTableRange>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_D3D12Pipe_RootTableRange(PyObject *self, Py_ssize_t idx)
{
  rdcarray<D3D12Pipe::RootTableRange> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootTableRange>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_D3D12Pipe_RootTableRange(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::RootTableRange> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootTableRange>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_D3D12Pipe_RootTableRange(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::RootTableRange> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootTableRange>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_D3D12Pipe_RootTableRange(PyObject *self, PyObject *idx)
{
  rdcarray<D3D12Pipe::RootTableRange> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootTableRange>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_D3D12Pipe_RootTableRange(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<D3D12Pipe::RootTableRange> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootTableRange>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_D3D12Pipe_RootTableRange(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::RootTableRange> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootTableRange>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_D3D12Pipe_RootTableRange(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::RootTableRange> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootTableRange>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_D3D12Pipe_RootTableRange(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::RootTableRange> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootTableRange>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_D3D12Pipe_RootTableRange(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::RootTableRange> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootTableRange>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_D3D12Pipe_RootParam(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_D3D12Pipe_RootParam",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_D3D12Pipe_RootParam' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_D3D12Pipe_RootParam' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  rdcarray< D3D12Pipe::RootParam > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam___eq__' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam___eq__' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam___eq__' argument 2 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam___eq__' argument 2 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::RootParam > const *)arg1)->operator ==((rdcarray< D3D12Pipe::RootParam > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  rdcarray< D3D12Pipe::RootParam > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam___ne__' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam___ne__' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam___ne__' argument 2 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam___ne__' argument 2 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::RootParam > const *)arg1)->operator !=((rdcarray< D3D12Pipe::RootParam > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  rdcarray< D3D12Pipe::RootParam > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam___lt__' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam___lt__' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam___lt__' argument 2 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam___lt__' argument 2 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::RootParam > const *)arg1)->operator <((rdcarray< D3D12Pipe::RootParam > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_RootParam_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  size_t arg2 ;
  D3D12Pipe::RootParam *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_RootParam_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_fill' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_fill' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_RootParam_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_D3D12Pipe__RootParam,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_D3D12Pipe_RootParam_fill" "', argument " "3"" of type '" "D3D12Pipe::RootParam const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_D3D12Pipe_RootParam_fill" "', argument " "3"" of type '" "D3D12Pipe::RootParam const &""'"); 
  }
  arg3 = reinterpret_cast< D3D12Pipe::RootParam * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(D3D12Pipe::RootParam const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_RootParam_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::RootParam const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::RootParam const &) >>("rdcarray_of_D3D12Pipe_RootParam_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::RootParam const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::RootParam const &) >>("rdcarray_of_D3D12Pipe_RootParam_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_append' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_append' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootParam_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_RootParam_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_clear' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_clear' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootParam_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_RootParam_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_insert' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_insert' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootParam_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_D3D12Pipe_RootParam_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_pop' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_pop' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootParam_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_D3D12Pipe_RootParam_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_sort' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_sort' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_D3D12Pipe_RootParam_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootParam_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_RootParam_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_copy' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_copy' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootParam_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_RootParam_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_reverse' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_reverse' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootParam_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_D3D12Pipe_RootParam_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_index' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_index' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootParam_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_count' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_count' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootParam_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_extend' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_extend' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootParam_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_RootParam_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::RootParam > *arg1 = (rdcarray< D3D12Pipe::RootParam > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::RootParam >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_RootParam_remove' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_RootParam_remove' argument 1 of type 'rdcarray< D3D12Pipe::RootParam >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_RootParam_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_D3D12Pipe_RootParam) /* defines _wrap_delete_rdcarray_of_D3D12Pipe_RootParam_destructor_closure */


PyObject *repr_rdcarray_of_D3D12Pipe_RootParam(PyObject *self)
{
  rdcarray<D3D12Pipe::RootParam> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootParam>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_D3D12Pipe_RootParam(PyObject *self, Py_ssize_t idx)
{
  rdcarray<D3D12Pipe::RootParam> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootParam>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_D3D12Pipe_RootParam(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::RootParam> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootParam>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_D3D12Pipe_RootParam(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::RootParam> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootParam>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_D3D12Pipe_RootParam(PyObject *self, PyObject *idx)
{
  rdcarray<D3D12Pipe::RootParam> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootParam>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_D3D12Pipe_RootParam(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<D3D12Pipe::RootParam> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootParam>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_D3D12Pipe_RootParam(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::RootParam> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootParam>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_D3D12Pipe_RootParam(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::RootParam> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootParam>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_D3D12Pipe_RootParam(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::RootParam> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootParam>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_D3D12Pipe_RootParam(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::RootParam> *thisptr = array_thisptr<rdcarray<D3D12Pipe::RootParam>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_D3D12Pipe_StaticSampler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_D3D12Pipe_StaticSampler",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_D3D12Pipe_StaticSampler' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_D3D12Pipe_StaticSampler' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  rdcarray< D3D12Pipe::StaticSampler > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler___eq__' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler___eq__' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler___eq__' argument 2 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler___eq__' argument 2 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::StaticSampler > const *)arg1)->operator ==((rdcarray< D3D12Pipe::StaticSampler > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  rdcarray< D3D12Pipe::StaticSampler > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler___ne__' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler___ne__' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler___ne__' argument 2 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler___ne__' argument 2 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::StaticSampler > const *)arg1)->operator !=((rdcarray< D3D12Pipe::StaticSampler > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  rdcarray< D3D12Pipe::StaticSampler > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler___lt__' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler___lt__' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler___lt__' argument 2 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler___lt__' argument 2 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< D3D12Pipe::StaticSampler > const *)arg1)->operator <((rdcarray< D3D12Pipe::StaticSampler > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_resize_for_index' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_StaticSampler_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  size_t arg2 ;
  D3D12Pipe::StaticSampler *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_StaticSampler_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_fill' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_fill' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_D3D12Pipe_StaticSampler_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_D3D12Pipe__StaticSampler,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_D3D12Pipe_StaticSampler_fill" "', argument " "3"" of type '" "D3D12Pipe::StaticSampler const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_D3D12Pipe_StaticSampler_fill" "', argument " "3"" of type '" "D3D12Pipe::StaticSampler const &""'"); 
  }
  arg3 = reinterpret_cast< D3D12Pipe::StaticSampler * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(D3D12Pipe::StaticSampler const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_StaticSampler_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_pop_back' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::StaticSampler const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_removeIf' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::StaticSampler const &) >>("rdcarray_of_D3D12Pipe_StaticSampler_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  SwigValueWrapper< std::function< bool (D3D12Pipe::StaticSampler const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_removeOneIf' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (D3D12Pipe::StaticSampler const &) >>("rdcarray_of_D3D12Pipe_StaticSampler_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_append' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_append' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_StaticSampler_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_clear' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_clear' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_StaticSampler_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_insert' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_insert' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_D3D12Pipe_StaticSampler_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_pop' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_pop' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_D3D12Pipe_StaticSampler_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_sort' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_sort' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_D3D12Pipe_StaticSampler_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_StaticSampler_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_copy' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_copy' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_D3D12Pipe_StaticSampler_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_reverse' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_reverse' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_D3D12Pipe_StaticSampler_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_index' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_index' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_count' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_count' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_extend' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_extend' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_D3D12Pipe_StaticSampler_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< D3D12Pipe::StaticSampler > *arg1 = (rdcarray< D3D12Pipe::StaticSampler > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< D3D12Pipe::StaticSampler >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_D3D12Pipe_StaticSampler_remove' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_D3D12Pipe_StaticSampler_remove' argument 1 of type 'rdcarray< D3D12Pipe::StaticSampler >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_D3D12Pipe_StaticSampler_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_D3D12Pipe_StaticSampler) /* defines _wrap_delete_rdcarray_of_D3D12Pipe_StaticSampler_destructor_closure */


PyObject *repr_rdcarray_of_D3D12Pipe_StaticSampler(PyObject *self)
{
  rdcarray<D3D12Pipe::StaticSampler> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StaticSampler>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_D3D12Pipe_StaticSampler(PyObject *self, Py_ssize_t idx)
{
  rdcarray<D3D12Pipe::StaticSampler> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StaticSampler>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_D3D12Pipe_StaticSampler(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::StaticSampler> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StaticSampler>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_D3D12Pipe_StaticSampler(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<D3D12Pipe::StaticSampler> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StaticSampler>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_D3D12Pipe_StaticSampler(PyObject *self, PyObject *idx)
{
  rdcarray<D3D12Pipe::StaticSampler> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StaticSampler>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_D3D12Pipe_StaticSampler(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<D3D12Pipe::StaticSampler> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StaticSampler>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_D3D12Pipe_StaticSampler(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::StaticSampler> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StaticSampler>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_D3D12Pipe_StaticSampler(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::StaticSampler> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StaticSampler>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_D3D12Pipe_StaticSampler(PyObject *self, PyObject *vals)
{
  rdcarray<D3D12Pipe::StaticSampler> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StaticSampler>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_D3D12Pipe_StaticSampler(PyObject *self, Py_ssize_t count)
{
  rdcarray<D3D12Pipe::StaticSampler> *thisptr = array_thisptr<rdcarray<D3D12Pipe::StaticSampler>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_GLPipe_VertexBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_GLPipe_VertexBuffer",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_GLPipe_VertexBuffer' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_GLPipe_VertexBuffer' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  rdcarray< GLPipe::VertexBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer___eq__' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer___eq__' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer___eq__' argument 2 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer___eq__' argument 2 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GLPipe::VertexBuffer > const *)arg1)->operator ==((rdcarray< GLPipe::VertexBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  rdcarray< GLPipe::VertexBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer___ne__' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer___ne__' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer___ne__' argument 2 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer___ne__' argument 2 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GLPipe::VertexBuffer > const *)arg1)->operator !=((rdcarray< GLPipe::VertexBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  rdcarray< GLPipe::VertexBuffer > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer___lt__' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer___lt__' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer___lt__' argument 2 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer___lt__' argument 2 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GLPipe::VertexBuffer > const *)arg1)->operator <((rdcarray< GLPipe::VertexBuffer > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_resize_for_index' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_resize_for_index' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_GLPipe_VertexBuffer_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  size_t arg2 ;
  GLPipe::VertexBuffer *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_VertexBuffer_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_fill' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_fill' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_GLPipe_VertexBuffer_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_GLPipe__VertexBuffer,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_GLPipe_VertexBuffer_fill" "', argument " "3"" of type '" "GLPipe::VertexBuffer const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_GLPipe_VertexBuffer_fill" "', argument " "3"" of type '" "GLPipe::VertexBuffer const &""'"); 
  }
  arg3 = reinterpret_cast< GLPipe::VertexBuffer * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(GLPipe::VertexBuffer const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_VertexBuffer_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_pop_back' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_pop_back' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (GLPipe::VertexBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_removeIf' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_removeIf' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (GLPipe::VertexBuffer const &) >>("rdcarray_of_GLPipe_VertexBuffer_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  SwigValueWrapper< std::function< bool (GLPipe::VertexBuffer const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_removeOneIf' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_removeOneIf' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (GLPipe::VertexBuffer const &) >>("rdcarray_of_GLPipe_VertexBuffer_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_append' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_append' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexBuffer_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_VertexBuffer_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_clear' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_clear' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexBuffer_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_VertexBuffer_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_insert' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_insert' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexBuffer_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_GLPipe_VertexBuffer_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_pop' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_pop' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexBuffer_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_GLPipe_VertexBuffer_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_sort' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_sort' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_GLPipe_VertexBuffer_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexBuffer_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_VertexBuffer_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_copy' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_copy' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexBuffer_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_VertexBuffer_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_reverse' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_reverse' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexBuffer_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_GLPipe_VertexBuffer_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_index' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_index' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexBuffer_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_count' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_count' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexBuffer_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_extend' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_extend' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexBuffer_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexBuffer_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexBuffer > *arg1 = (rdcarray< GLPipe::VertexBuffer > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexBuffer >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexBuffer_remove' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexBuffer_remove' argument 1 of type 'rdcarray< GLPipe::VertexBuffer >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexBuffer_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_GLPipe_VertexBuffer) /* defines _wrap_delete_rdcarray_of_GLPipe_VertexBuffer_destructor_closure */


PyObject *repr_rdcarray_of_GLPipe_VertexBuffer(PyObject *self)
{
  rdcarray<GLPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<GLPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_GLPipe_VertexBuffer(PyObject *self, Py_ssize_t idx)
{
  rdcarray<GLPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<GLPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_GLPipe_VertexBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<GLPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<GLPipe::VertexBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_GLPipe_VertexBuffer(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<GLPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<GLPipe::VertexBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_GLPipe_VertexBuffer(PyObject *self, PyObject *idx)
{
  rdcarray<GLPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<GLPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_GLPipe_VertexBuffer(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<GLPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<GLPipe::VertexBuffer>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_GLPipe_VertexBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<GLPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<GLPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_GLPipe_VertexBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<GLPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<GLPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_GLPipe_VertexBuffer(PyObject *self, PyObject *vals)
{
  rdcarray<GLPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<GLPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_GLPipe_VertexBuffer(PyObject *self, Py_ssize_t count)
{
  rdcarray<GLPipe::VertexBuffer> *thisptr = array_thisptr<rdcarray<GLPipe::VertexBuffer>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_GLPipe_VertexAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_GLPipe_VertexAttribute",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_GLPipe_VertexAttribute' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_GLPipe_VertexAttribute' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  rdcarray< GLPipe::VertexAttribute > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute___eq__' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute___eq__' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute___eq__' argument 2 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute___eq__' argument 2 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GLPipe::VertexAttribute > const *)arg1)->operator ==((rdcarray< GLPipe::VertexAttribute > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  rdcarray< GLPipe::VertexAttribute > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute___ne__' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute___ne__' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute___ne__' argument 2 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute___ne__' argument 2 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GLPipe::VertexAttribute > const *)arg1)->operator !=((rdcarray< GLPipe::VertexAttribute > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  rdcarray< GLPipe::VertexAttribute > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute___lt__' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute___lt__' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute___lt__' argument 2 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute___lt__' argument 2 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GLPipe::VertexAttribute > const *)arg1)->operator <((rdcarray< GLPipe::VertexAttribute > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_resize_for_index' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_resize_for_index' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_GLPipe_VertexAttribute_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  size_t arg2 ;
  GLPipe::VertexAttribute *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_VertexAttribute_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_fill' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_fill' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_GLPipe_VertexAttribute_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_GLPipe__VertexAttribute,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_GLPipe_VertexAttribute_fill" "', argument " "3"" of type '" "GLPipe::VertexAttribute const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_GLPipe_VertexAttribute_fill" "', argument " "3"" of type '" "GLPipe::VertexAttribute const &""'"); 
  }
  arg3 = reinterpret_cast< GLPipe::VertexAttribute * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(GLPipe::VertexAttribute const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_VertexAttribute_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_pop_back' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_pop_back' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  SwigValueWrapper< std::function< bool (GLPipe::VertexAttribute const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_removeIf' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_removeIf' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (GLPipe::VertexAttribute const &) >>("rdcarray_of_GLPipe_VertexAttribute_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  SwigValueWrapper< std::function< bool (GLPipe::VertexAttribute const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_removeOneIf' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_removeOneIf' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (GLPipe::VertexAttribute const &) >>("rdcarray_of_GLPipe_VertexAttribute_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_append' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_append' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexAttribute_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_VertexAttribute_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_clear' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_clear' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexAttribute_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_VertexAttribute_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_insert' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_insert' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexAttribute_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_GLPipe_VertexAttribute_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_pop' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_pop' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexAttribute_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_GLPipe_VertexAttribute_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_sort' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_sort' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_GLPipe_VertexAttribute_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexAttribute_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_VertexAttribute_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_copy' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_copy' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexAttribute_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_VertexAttribute_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_reverse' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_reverse' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexAttribute_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_GLPipe_VertexAttribute_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_index' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_index' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexAttribute_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_count' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_count' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexAttribute_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_extend' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_extend' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexAttribute_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_VertexAttribute_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::VertexAttribute > *arg1 = (rdcarray< GLPipe::VertexAttribute > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::VertexAttribute >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_VertexAttribute_remove' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_VertexAttribute_remove' argument 1 of type 'rdcarray< GLPipe::VertexAttribute >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_VertexAttribute_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_GLPipe_VertexAttribute) /* defines _wrap_delete_rdcarray_of_GLPipe_VertexAttribute_destructor_closure */


PyObject *repr_rdcarray_of_GLPipe_VertexAttribute(PyObject *self)
{
  rdcarray<GLPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<GLPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_GLPipe_VertexAttribute(PyObject *self, Py_ssize_t idx)
{
  rdcarray<GLPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<GLPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_GLPipe_VertexAttribute(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<GLPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<GLPipe::VertexAttribute>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_GLPipe_VertexAttribute(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<GLPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<GLPipe::VertexAttribute>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_GLPipe_VertexAttribute(PyObject *self, PyObject *idx)
{
  rdcarray<GLPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<GLPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_GLPipe_VertexAttribute(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<GLPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<GLPipe::VertexAttribute>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_GLPipe_VertexAttribute(PyObject *self, PyObject *vals)
{
  rdcarray<GLPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<GLPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_GLPipe_VertexAttribute(PyObject *self, Py_ssize_t count)
{
  rdcarray<GLPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<GLPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_GLPipe_VertexAttribute(PyObject *self, PyObject *vals)
{
  rdcarray<GLPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<GLPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_GLPipe_VertexAttribute(PyObject *self, Py_ssize_t count)
{
  rdcarray<GLPipe::VertexAttribute> *thisptr = array_thisptr<rdcarray<GLPipe::VertexAttribute>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

SWIGINTERN PyObject *_wrap_delete_rdcarray_of_GLPipe_TextureCompleteness(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"delete_rdcarray_of_GLPipe_TextureCompleteness",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'delete_rdcarray_of_GLPipe_TextureCompleteness' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'delete_rdcarray_of_GLPipe_TextureCompleteness' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  rdcarray< GLPipe::TextureCompleteness > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness___eq__' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness___eq__' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness___eq__' argument 2 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness___eq__' argument 2 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GLPipe::TextureCompleteness > const *)arg1)->operator ==((rdcarray< GLPipe::TextureCompleteness > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  rdcarray< GLPipe::TextureCompleteness > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness___ne__' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness___ne__' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness___ne__' argument 2 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness___ne__' argument 2 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GLPipe::TextureCompleteness > const *)arg1)->operator !=((rdcarray< GLPipe::TextureCompleteness > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  rdcarray< GLPipe::TextureCompleteness > *arg2 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  unsigned char tempmem2[32] ;
  bool wasSelf2 = false ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness___lt__' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness___lt__' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    using array_type = std::remove_pointer<decltype(arg2)>::type;
    
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem2) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg2, tempmem2);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(swig_obj[0], indirect(arg2), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness___lt__' argument 2 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness___lt__' argument 2 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg2); 
  }
  result = (bool)((rdcarray< GLPipe::TextureCompleteness > const *)arg1)->operator <((rdcarray< GLPipe::TextureCompleteness > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_resize_for_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  size_t arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_resize_for_index' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_resize_for_index' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_GLPipe_TextureCompleteness_resize_for_index" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->resize_for_index(arg2);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_fill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  size_t arg2 ;
  GLPipe::TextureCompleteness *arg3 = 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_TextureCompleteness_fill",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_fill' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_fill' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rdcarray_of_GLPipe_TextureCompleteness_fill" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_GLPipe__TextureCompleteness,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rdcarray_of_GLPipe_TextureCompleteness_fill" "', argument " "3"" of type '" "GLPipe::TextureCompleteness const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rdcarray_of_GLPipe_TextureCompleteness_fill" "', argument " "3"" of type '" "GLPipe::TextureCompleteness const &""'"); 
  }
  arg3 = reinterpret_cast< GLPipe::TextureCompleteness * >(argp3);
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->fill(arg2,(GLPipe::TextureCompleteness const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_TextureCompleteness_pop_back",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_pop_back' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_pop_back' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_removeIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  SwigValueWrapper< std::function< bool (GLPipe::TextureCompleteness const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_removeIf' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_removeIf' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (GLPipe::TextureCompleteness const &) >>("rdcarray_of_GLPipe_TextureCompleteness_removeIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_removeOneIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  SwigValueWrapper< std::function< bool (GLPipe::TextureCompleteness const &) > > arg2 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  StackExceptionHandler exHandle2 ;
  PyObject *swig_obj[2] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_removeOneIf' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_removeOneIf' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    PyObject *func = swig_obj[0];
    arg2 = ConvertFunc<std::function< bool (GLPipe::TextureCompleteness const &) >>("rdcarray_of_GLPipe_TextureCompleteness_removeOneIf", func, exHandle2);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  (arg1)->removeOneIf(arg2);
  resultobj = SWIG_Py_Void();
  {
    if(exHandle2.data().failFlag) {
      PyErr_Restore(exHandle2.data().exObj, exHandle2.data().valueObj, exHandle2.data().tracebackObj);
      SWIG_fail;
    }
  }
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_append' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_append' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_TextureCompleteness_Sg__append(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_TextureCompleteness_clear",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_clear' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_clear' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_TextureCompleteness_Sg__clear(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_TextureCompleteness_insert",2,2,swig_obj)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_insert' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_insert' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  arg3 = swig_obj[1];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_TextureCompleteness_Sg__insert(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_pop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  char *  kwnames[] = {
    (char *) "index", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:rdcarray_of_GLPipe_TextureCompleteness_pop",kwnames,&obj1)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_pop' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_pop' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_TextureCompleteness_Sg__pop(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_sort(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  PyObject *arg2 = (PyObject *) NULL ;
  bool arg3 = (bool) false ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *  kwnames[] = {
    (char *) "key",(char *) "reverse", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:rdcarray_of_GLPipe_TextureCompleteness_sort",kwnames,&obj1,&obj2)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_sort' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_sort' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rdcarray_of_GLPipe_TextureCompleteness_sort" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_TextureCompleteness_Sg__sort(arg1,arg2,arg3);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_TextureCompleteness_copy",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_copy' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_copy' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_TextureCompleteness_Sg__copy(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args,"rdcarray_of_GLPipe_TextureCompleteness_reverse",0,0,0)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_reverse' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_reverse' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_TextureCompleteness_Sg__reverse(arg1);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) NULL ;
  PyObject *arg4 = (PyObject *) NULL ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *  kwnames[] = {
    (char *) "item",(char *) "start",(char *) "end", NULL 
  };
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:rdcarray_of_GLPipe_TextureCompleteness_index",kwnames,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_index' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_index' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  if (obj3) {
    arg4 = obj3;
  }
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_TextureCompleteness_Sg__index(arg1,arg2,arg3,arg4);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_count' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_count' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_TextureCompleteness_Sg__count(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_extend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_extend' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_extend' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_TextureCompleteness_Sg__extend(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rdcarray_of_GLPipe_TextureCompleteness_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  rdcarray< GLPipe::TextureCompleteness > *arg1 = (rdcarray< GLPipe::TextureCompleteness > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  unsigned char tempmem1[32] ;
  bool wasSelf1 = false ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    using array_type = std::remove_pointer<decltype(arg1)>::type;
    
    // don't convert 'self', leave as-is so we can modify by reference. Everything else needs to be
    // converted/copied to allow passing lists (or any sequence) python objects to a function
    // expecting a particular C++ array type
    constexpr bool isSelf = STR_EQ(self, self);
    wasSelf1 = isSelf;
    if(isSelf)
    {
      // we use an indirect dispatch class here (see self_dispatch) to avoid the need to instantiate
      // the conversion template for types we don't care about
      arg1 = self_dispatch<isSelf>::getthis<array_type>(self);
    }
    else
    {
      // convert the sequence by value using ConvertFromPy
      static_assert(sizeof(tempmem1) >= sizeof(array_type), "not enough temp space for rdcarray< GLPipe::TextureCompleteness >");
      
      tempalloc(arg1, tempmem1);
      
      int failIdx = 0;
      int res = TypeConversion<array_type>::ConvertFromPy(self, indirect(arg1), &failIdx);
      
      if(!SWIG_IsOK(res))
      {
        if(res == SWIG_TypeError)
        {
          SWIG_exception_fail(SWIG_ArgError(res), "in method 'rdcarray_of_GLPipe_TextureCompleteness_remove' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >'"); 
        }
        else
        {
          snprintf(convert_error, sizeof(convert_error)-1, "in method 'rdcarray_of_GLPipe_TextureCompleteness_remove' argument 1 of type 'rdcarray< GLPipe::TextureCompleteness >', decoding element %d", failIdx);
          SWIG_exception_fail(SWIG_ArgError(res), convert_error);
        }
      }
    }
  }
  arg2 = swig_obj[0];
  {
    add_your_use_of_rdcarray_to_swig_interface (arg1); 
  }
  result = (PyObject *)rdcarray_Sl_GLPipe_TextureCompleteness_Sg__remove(arg1,arg2);
  resultobj = result;
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return resultobj;
fail:
  {
    // if we converted the sequence by-value, then destroy it again
    if(!wasSelf1)
    tempdealloc(arg1);
  }
  return NULL;
}


SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_rdcarray_of_GLPipe_TextureCompleteness) /* defines _wrap_delete_rdcarray_of_GLPipe_TextureCompleteness_destructor_closure */


PyObject *repr_rdcarray_of_GLPipe_TextureCompleteness(PyObject *self)
{
  rdcarray<GLPipe::TextureCompleteness> *thisptr = array_thisptr<rdcarray<GLPipe::TextureCompleteness>>(self);

  if(!thisptr)
    return NULL;

  return array_repr(thisptr);
}

PyObject *getitem_rdcarray_of_GLPipe_TextureCompleteness(PyObject *self, Py_ssize_t idx)
{
  rdcarray<GLPipe::TextureCompleteness> *thisptr = array_thisptr<rdcarray<GLPipe::TextureCompleteness>>(self);

  if(!thisptr)
    return NULL;

  return array_getitem(thisptr, idx);
}

int setitem_rdcarray_of_GLPipe_TextureCompleteness(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<GLPipe::TextureCompleteness> *thisptr = array_thisptr<rdcarray<GLPipe::TextureCompleteness>>(self);

  if(!thisptr)
    return -1;

  return array_setitem(thisptr, idx, val);
}

Py_ssize_t length_rdcarray_of_GLPipe_TextureCompleteness(PyObject *self, Py_ssize_t idx, PyObject *val)
{
  rdcarray<GLPipe::TextureCompleteness> *thisptr = array_thisptr<rdcarray<GLPipe::TextureCompleteness>>(self);

  if(!thisptr)
    return -1;

  return array_len(thisptr);
}

PyObject *getsubscript_rdcarray_of_GLPipe_TextureCompleteness(PyObject *self, PyObject *idx)
{
  rdcarray<GLPipe::TextureCompleteness> *thisptr = array_thisptr<rdcarray<GLPipe::TextureCompleteness>>(self);

  if(!thisptr)
    return NULL;

  return array_getsubscript(thisptr, idx);
}

int setsubscript_rdcarray_of_GLPipe_TextureCompleteness(PyObject *self, PyObject *idx, PyObject *val)
{
  rdcarray<GLPipe::TextureCompleteness> *thisptr = array_thisptr<rdcarray<GLPipe::TextureCompleteness>>(self);

  if(!thisptr)
    return -1;

  return array_setsubscript(thisptr, idx, val);
}

PyObject *concat_rdcarray_of_GLPipe_TextureCompleteness(PyObject *self, PyObject *vals)
{
  rdcarray<GLPipe::TextureCompleteness> *thisptr = array_thisptr<rdcarray<GLPipe::TextureCompleteness>>(self);

  if(!thisptr)
    return NULL;

  return array_concat(thisptr, vals);
}

PyObject *repeat_rdcarray_of_GLPipe_TextureCompleteness(PyObject *self, Py_ssize_t count)
{
  rdcarray<GLPipe::TextureCompleteness> *thisptr = array_thisptr<rdcarray<GLPipe::TextureCompleteness>>(self);

  if(!thisptr)
    return NULL;

  return array_repeat(thisptr, count);
}

PyObject *selfconcat_rdcarray_of_GLPipe_TextureCompleteness(PyObject *self, PyObject *vals)
{
  rdcarray<GLPipe::TextureCompleteness> *thisptr = array_thisptr<rdcarray<GLPipe::TextureCompleteness>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfconcat(thisptr, vals);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}

PyObject *selfrepeat_rdcarray_of_GLPipe_TextureCompleteness(PyObject *self, Py_ssize_t count)
{
  rdcarray<GLPipe::TextureCompleteness> *thisptr = array_thisptr<rdcarray<GLPipe::TextureCompleteness>>(self);

  if(!thisptr)
    return NULL;

  PyObject *ret = array_selfrepeat(thisptr, count);

  if(ret)
  {
    Py_DECREF(ret);
    return Py_NewRef(self);
  }

  return NULL;
}



PyObject *PassObjectToPython(const char *type, void *obj)
{
  swig_type_info *t = SWIG_TypeQuery(type);
  if(t == NULL)
    return NULL;

  return SWIG_InternalNewPointerObj(obj, t, 0);
}

PyObject *PassNewObjectToPython(const char *type, void *obj)
{
  swig_type_info *t = SWIG_TypeQuery(type);
  if(t == NULL)
    return NULL;

  return SWIG_InternalNewPointerObj(obj, t, SWIG_POINTER_OWN);
}

extern "C" PyObject *RENDERDOC_DumpObject(PyObject *obj)
{
  void *resptr = NULL;

  // for basic types, return the repr directly
  if(Py_IsTrue(obj) ||
     Py_IsFalse(obj) ||
     Py_IsNone(obj) ||
     PyObject_IsInstance(obj, (PyObject*)&PyFloat_Type) ||
     PyObject_IsInstance(obj, (PyObject*)&PyLong_Type) ||
     PyObject_IsInstance(obj, (PyObject*)&PyBytes_Type) ||
     PyObject_IsInstance(obj, (PyObject*)&PyUnicode_Type) ||
     PyObject_IsInstance(obj, (PyObject*)&PyList_Type) ||
     PyObject_IsInstance(obj, (PyObject*)&PyDict_Type) ||
     PyObject_IsInstance(obj, (PyObject*)&PyTuple_Type))
  {
    return PyObject_Repr(obj);
  }

  // also for ResourceId
  if(SWIG_ConvertPtr(obj, &resptr, SWIGTYPE_p_ResourceId, 0) != -1)
  {
    return PyObject_Repr(obj);
  }

  PyObject *ret;
  
  if(PySequence_Check(obj))
  {
    ret = PyList_New(0);

    Py_ssize_t size = PySequence_Size(obj);

    for(Py_ssize_t i = 0; i < size; i++)
    {
      PyObject *entry = PySequence_GetItem(obj, i);

      // don't add callables
      if(PyCallable_Check(entry) == 0)
      {
        PyObject *childDump = RENDERDOC_DumpObject(entry);
        PyList_Append(ret, childDump);
        Py_XDECREF(childDump);
      }

      Py_XDECREF(entry);
    }
  }
  else
  {
    ret = PyDict_New();

    // otherwise iterate over the dir
    PyObject *dir = PyObject_Dir(obj);

    Py_ssize_t size = PyList_Size(dir);

    for(Py_ssize_t i = 0; i < size; i++)
    {
      PyObject *member = PyList_GetItem(dir, i);

      PyObject *bytes = PyUnicode_AsUTF8String(member);

      if(!bytes)
        continue;

      char *buf = NULL;
      Py_ssize_t size = 0;

      if(PyBytes_AsStringAndSize(bytes, &buf, &size) == 0)
      {
        rdcstr name;
        name.assign(buf, size);

        if(name.beginsWith("__") || name == "this" || name == "thisown" || name == "acquire")
        {
          // skip this member, it's internal
        }
        else
        {
          PyObject *child = PyObject_GetAttr(obj, member);

          // don't add callables
          if(PyCallable_Check(child) == 0)
          {
            PyObject *childDump = RENDERDOC_DumpObject(child);
            PyDict_SetItem(ret, member, childDump);
            Py_XDECREF(childDump);
          }
        }
      }

      Py_XDECREF(bytes);
    }

    Py_XDECREF(dir);
  }

  return ret;
}


static PyMethodDef SwigMethods[] = {
	 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { (char *)"CreateHeadlessWindowingData", _wrap_CreateHeadlessWindowingData, METH_VARARGS, (char *)"\n"
		"CreateHeadlessWindowingData(width, height)\n"
		"\n"
		"Create a :class:`WindowingData` for no backing window, it will be headless.\n"
		"\n"
		":param int width: The initial width for this virtual window.\n"
		":param int height: The initial height for this virtual window.\n"
		"\n"
		":return: A :class:`WindowingData` corresponding to an 'empty' backing window.\n"
		":rtype: WindowingData\n"
		"\n"
		""},
	 { (char *)"CreateWin32WindowingData", (PyCFunction)_wrap_CreateWin32WindowingData, METH_O, (char *)"\n"
		"CreateWin32WindowingData(window)\n"
		"\n"
		"Create a :class:`WindowingData` for a Win32 ``HWND`` handle.\n"
		"\n"
		":param HWND window: The native ``HWND`` handle for this window.\n"
		":return: A :class:`WindowingData` corresponding to the given window.\n"
		":rtype: WindowingData\n"
		"\n"
		""},
	 { (char *)"CreateXlibWindowingData", _wrap_CreateXlibWindowingData, METH_VARARGS, (char *)"\n"
		"CreateXlibWindowingData(display, window)\n"
		"\n"
		"Create a :class:`WindowingData` for an Xlib ``Drawable`` handle.\n"
		"\n"
		":param Display display: The ``Display`` connection used for this window.\n"
		":param Drawable window: The native ``Drawable`` handle for this window.\n"
		":return: A :class:`WindowingData` corresponding to the given window.\n"
		":rtype: WindowingData\n"
		"\n"
		""},
	 { (char *)"CreateXCBWindowingData", _wrap_CreateXCBWindowingData, METH_VARARGS, (char *)"\n"
		"CreateXCBWindowingData(connection, window)\n"
		"\n"
		"Create a :class:`WindowingData` for an XCB ``xcb_window_t`` handle.\n"
		"\n"
		":param xcb_connection_t connection: The ``xcb_connection_t`` connection used for this window.\n"
		":param xcb_window_t window: The native ``xcb_window_t`` handle for this window.\n"
		":return: A :class:`WindowingData` corresponding to the given window.\n"
		":rtype: WindowingData\n"
		"\n"
		""},
	 { (char *)"CreateWaylandWindowingData", _wrap_CreateWaylandWindowingData, METH_VARARGS, (char *)"\n"
		"CreateWaylandWindowingData(display, window)\n"
		"\n"
		"Create a :class:`WindowingData` for an Wayland ``wl_surface`` handle.\n"
		"\n"
		":param wl_display display: The ``wl_display`` connection used for this window.\n"
		":param wl_surface window: The native ``wl_surface`` handle for this window.\n"
		":return: A :class:`WindowingData` corresponding to the given window.\n"
		":rtype: WindowingData\n"
		"\n"
		""},
	 { (char *)"CreateAndroidWindowingData", (PyCFunction)_wrap_CreateAndroidWindowingData, METH_O, (char *)"\n"
		"CreateAndroidWindowingData(window)\n"
		"\n"
		"Create a :class:`WindowingData` for an Android ``ANativeWindow`` handle.\n"
		"\n"
		":param ANativeWindow window: The native ``ANativeWindow`` handle for this window.\n"
		":return: A :class:`WindowingData` corresponding to the given window.\n"
		":rtype: WindowingData\n"
		"\n"
		""},
	 { (char *)"CreateMacOSWindowingData", _wrap_CreateMacOSWindowingData, METH_VARARGS, (char *)"\n"
		"CreateMacOSWindowingData(view, layer)\n"
		"\n"
		"Create a :class:`WindowingData` for an metal/opengl-compatible macOS ``CALayer`` handle\n"
		"and ``NSView`` handle (as void pointers).\n"
		"\n"
		":param NSView view: The native ``NSView`` handle for this window.\n"
		":param CALayer layer: The native ``CALayer`` handle for this window.\n"
		":return: A :class:`WindowingData` corresponding to the given window.\n"
		":rtype: WindowingData\n"
		"\n"
		""},
	 { (char *)"InitCamera", (PyCFunction)_wrap_InitCamera, METH_O, (char *)"\n"
		"InitCamera(type)\n"
		"\n"
		"Create a new camera of a given type.\n"
		"\n"
		":param CameraType type: The type of controls to use\n"
		":return: The handle to the new camera.\n"
		":rtype: Camera\n"
		"\n"
		""},
	 { (char *)"HalfToFloat", (PyCFunction)_wrap_HalfToFloat, METH_O, (char *)"\n"
		"HalfToFloat(half)\n"
		"\n"
		"A utility function that converts a half (stored in a 16-bit unsigned integer) to a\n"
		"float.\n"
		"\n"
		":param int half: The half stored as an int.\n"
		":return: The floating point equivalent.\n"
		":rtype: float\n"
		"\n"
		""},
	 { (char *)"FloatToHalf", (PyCFunction)_wrap_FloatToHalf, METH_O, (char *)"\n"
		"FloatToHalf(flt)\n"
		"\n"
		"A utility function that converts a float to a half (stored in a 16-bit unsigned\n"
		"integer).\n"
		"\n"
		":param float flt: The floating point value.\n"
		":return: The nearest half-float equivalent stored as an int.\n"
		":rtype: int\n"
		"\n"
		""},
	 { (char *)"NumVerticesPerPrimitive", (PyCFunction)_wrap_NumVerticesPerPrimitive, METH_O, (char *)"\n"
		"NumVerticesPerPrimitive(topology)\n"
		"\n"
		"A utility function that returns the number of vertices in a primitive of a given\n"
		"topology.\n"
		"\n"
		".. note:: In strip topologies vertices are re-used.\n"
		"\n"
		":param Topology topology: The topology to query about.\n"
		":return: The number of vertices in a single primitive.\n"
		":rtype: int\n"
		"\n"
		""},
	 { (char *)"VertexOffset", _wrap_VertexOffset, METH_VARARGS, (char *)"\n"
		"VertexOffset(topology, primitive)\n"
		"\n"
		"A utility function that returns the offset in the list of vertices of the first vertex\n"
		"in a particular primitive of a given topology. This calculation is simple but not trivial for the\n"
		"case of strip topologies.\n"
		"\n"
		":param Topology topology: The topology to query about.\n"
		":param int primitive: The primitive to query about.\n"
		":return: The vertex offset where the primitive starts.\n"
		":rtype: int\n"
		"\n"
		""},
	 { (char *)"OpenCaptureFile", (PyCFunction)_wrap_OpenCaptureFile, METH_NOARGS, (char *)"\n"
		"OpenCaptureFile()\n"
		"\n"
		"Create a handle for a capture file.\n"
		"\n"
		"This function returns a new handle to a capture file. Once initialised by opening a file the handle\n"
		"can only be shut-down, it is not re-usable.\n"
		"\n"
		":return: A handle to the specified path.\n"
		":rtype: CaptureFile\n"
		"\n"
		""},
	 { (char *)"CreateTargetControl", _wrap_CreateTargetControl, METH_VARARGS, (char *)"\n"
		"CreateTargetControl(URL, ident, clientName, forceConnection)\n"
		"\n"
		"Creates a :class:`TargetControl` connection to a given hostname and ident.\n"
		"\n"
		"This function will block until the control connection is ready, or an error occurs.\n"
		"\n"
		":param str URL: The URL to connect to. If blank, the local machine is used. If no protocol is\n"
		"  specified then default TCP enumeration happens.\n"
		":param int ident: The ident for the particular target to connect to on that machine.\n"
		":param str clientName: The client name to use when connecting. See\n"
		"  :meth:`TargetControl.GetBusyClient`.\n"
		":param bool forceConnection: Force the connection and kick off any existing client that is currently\n"
		"  connected.\n"
		":return: A handle to the target control connection, or ``None`` if something went wrong.\n"
		":rtype: TargetControl\n"
		"\n"
		""},
	 { (char *)"EnumerateRemoteTargets", _wrap_EnumerateRemoteTargets, METH_VARARGS, (char *)"\n"
		"EnumerateRemoteTargets(URL, nextIdent)\n"
		"\n"
		"Repeatedly query to enumerate which targets are active on a given machine and their\n"
		"idents.\n"
		"\n"
		"Initially this should be called with ``nextIdent`` being 0, to retrieve the first target\n"
		"active. After that it can be called again and again with the previous return value to enumerate\n"
		"more targets.\n"
		"\n"
		"This function will block for a variable timeout depending on how many targets are scanned.\n"
		"\n"
		":param str URL: The URL to connect to. If blank, the local machine is used. If no protocol is\n"
		"  specified then default TCP enumeration happens.\n"
		":param int nextIdent: The next ident to scan.\n"
		":return: The ident of the next active target, or ``0`` if no other targets exist.\n"
		":rtype: int\n"
		"\n"
		""},
	 { (char *)"CreateRemoteServerConnection", (PyCFunction)_wrap_CreateRemoteServerConnection, METH_O, (char *)"\n"
		"CreateRemoteServerConnection(URL)\n"
		"\n"
		"Create a connection to a remote server running on given hostname.\n"
		"\n"
		":param str URL: The hostname to connect to, if blank then localhost is used. If no protocol is\n"
		"  specified then default TCP enumeration happens.\n"
		":return: The status of opening the connection, whether success or failure, and a :class:`RemoteServer`\n"
		"  instance if it were successful\n"
		":rtype: Tuple[ResultDetails,RemoteServer]\n"
		"\n"
		""},
	 { (char *)"CheckRemoteServerConnection", (PyCFunction)_wrap_CheckRemoteServerConnection, METH_O, (char *)"\n"
		"CheckRemoteServerConnection(URL)\n"
		"\n"
		"Check the connection to a remote server running on given hostname.\n"
		"\n"
		"This should be preferred to :func:`CreateRemoteServerConnection` when no connection is desired, as\n"
		"the status can be checked without interfering with making connections.\n"
		"\n"
		":param str URL: The hostname to connect to, if blank then localhost is used. If no protocol is\n"
		"  specified then default TCP enumeration happens.\n"
		":return: The status of the server.\n"
		":rtype: ResultDetails\n"
		"\n"
		""},
	 { (char *)"BecomeRemoteServer", _wrap_BecomeRemoteServer, METH_VARARGS, (char *)"\n"
		"BecomeRemoteServer(listenhost, port, killReplay, previewWindow)\n"
		"\n"
		"This launches a remote server which will continually run in a loop to server requests\n"
		"from external sources.\n"
		"\n"
		"This function will block until a remote connection tells the server to shut down, or the\n"
		"``killReplay`` callback returns ``True``.\n"
		"\n"
		":param str listenhost: The name of the interface to listen on.\n"
		":param int port: The port to listen on, or ``0`` to listen on the default port.\n"
		":param KillCallback killReplay: A callback that returns a ``bool`` indicating if the server should\n"
		"  be shut down or not.\n"
		"  Callback function signature must match :func:`KillCallback`.\n"
		":param PreviewWindowCallback previewWindow: A callback that returns information for a preview window\n"
		"  when the server wants to display some preview of the ongoing replay.\n"
		"  Callback function signature must match :func:`PreviewWindowCallback`.\n"
		"\n"
		""},
	 { (char *)"GetDefaultCaptureOptions", (PyCFunction)_wrap_GetDefaultCaptureOptions, METH_NOARGS, (char *)"\n"
		"GetDefaultCaptureOptions()\n"
		"\n"
		"Retrieve the default and recommended set of capture options.\n"
		"\n"
		":return: The default capture options.\n"
		":rtype: CaptureOptions\n"
		"\n"
		""},
	 { (char *)"StartGlobalHook", _wrap_StartGlobalHook, METH_VARARGS, (char *)"\n"
		"StartGlobalHook(pathmatch, logfile, opts)\n"
		"\n"
		"Begin injecting speculatively into all new processes started on the system. Where\n"
		"supported by platform, configuration, and setup begin injecting speculatively into all new processes\n"
		"started on the system.\n"
		"\n"
		"This function can only be called if global hooking is supported (see :func:`CanGlobalHook`) and if\n"
		"global hooking is not active (see :func:`IsGlobalHookActive`).\n"
		"\n"
		"The hook must be closed with :func:`StopGlobalHook` before the application is closed.\n"
		"\n"
		"This function must be called when the process is running with administrator/superuser permissions.\n"
		"\n"
		":param str pathmatch: A string to match against each new process's executable path to determine\n"
		"  which corresponds to the program we actually want to capture.\n"
		":param str logfile: Where to store any captures.\n"
		":param CaptureOptions opts: The capture options to use when injecting into the program.\n"
		":return: The result of the operation, if the result succeeded the hook is now active.\n"
		":rtype: ResultDetails\n"
		"\n"
		""},
	 { (char *)"StopGlobalHook", (PyCFunction)_wrap_StopGlobalHook, METH_NOARGS, (char *)"\n"
		"StopGlobalHook()\n"
		"\n"
		"Stop the global hook that was activated by :func:`StartGlobalHook`.\n"
		"\n"
		"This function can only be called if global hooking is supported (see :func:`CanGlobalHook`) and if\n"
		"global hooking is active (see :func:`IsGlobalHookActive`).\n"
		"\n"
		""},
	 { (char *)"IsGlobalHookActive", (PyCFunction)_wrap_IsGlobalHookActive, METH_NOARGS, (char *)"\n"
		"IsGlobalHookActive()\n"
		"\n"
		"Determines if the global hook is active or not.\n"
		"\n"
		"This function can only be called if global hooking is supported (see :func:`CanGlobalHook`).\n"
		"\n"
		":return: ``True`` if the hook is active, or ``False`` if the hook is inactive.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"CanGlobalHook", (PyCFunction)_wrap_CanGlobalHook, METH_NOARGS, (char *)"\n"
		"CanGlobalHook()\n"
		"\n"
		"Determines if the global hook is supported on the current platform and configuration.\n"
		"\n"
		":return: ``True`` if global hooking can be used on the platform, ``False`` if not.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"ExecuteAndInject", _wrap_ExecuteAndInject, METH_VARARGS, (char *)"\n"
		"ExecuteAndInject(app, workingDir, cmdLine, env, capturefile, opts, waitForExit)\n"
		"\n"
		"Launch an application and inject into it to allow capturing.\n"
		"\n"
		":param str app: The path to the application to run.\n"
		":param str workingDir: The working directory to use when running the application. If blank, the\n"
		"  directory containing the application is used.\n"
		":param str cmdLine: The command line to use when running the application, it will be processed in a\n"
		"  platform specific way to generate arguments.\n"
		":param List[EnvironmentModification] env: Any environment changes that should be made when running\n"
		"  the program.\n"
		":param str capturefile: The capture file path template, or blank to use a default location.\n"
		":param CaptureOptions opts: The capture options to use when injecting into the program.\n"
		":param bool waitForExit: If ``True`` this function will block until the process exits.\n"
		":return: The :class:`ExecuteResult` indicating both the status of the operation (success or failure)\n"
		"  and any reason for failure, or else the ident where the new application is listening for target\n"
		"  control if everything succeeded.\n"
		":rtype: ExecuteResult\n"
		"\n"
		""},
	 { (char *)"InjectIntoProcess", _wrap_InjectIntoProcess, METH_VARARGS, (char *)"\n"
		"InjectIntoProcess(pid, env, capturefile, opts, waitForExit)\n"
		"\n"
		"Where supported by operating system and permissions, inject into a running process.\n"
		"\n"
		":param int pid: The Process ID (PID) to inject into.\n"
		":param List[EnvironmentModification] env: Any environment changes that should be made when running\n"
		"  the program.\n"
		":param str capturefile: The capture file path template, or blank to use a default location.\n"
		":param CaptureOptions opts: The capture options to use when injecting into the program.\n"
		":param bool waitForExit: If ``True`` this function will block until the process exits.\n"
		":return: The :class:`ExecuteResult` indicating both the status of the operation (success or failure)\n"
		"  and any reason for failure, or else the ident where the new application is listening for target\n"
		"  control if everything succeeded.\n"
		":rtype: ExecuteResult\n"
		"\n"
		""},
	 { (char *)"CanSelfHostedCapture", (PyCFunction)_wrap_CanSelfHostedCapture, METH_O, (char *)"\n"
		"CanSelfHostedCapture(dllname)\n"
		"\n"
		"When debugging RenderDoc it can be useful to capture itself by doing a side-build with a\n"
		"temporary name. This function checks to see if a given self-hosted DLL is available.\n"
		"\n"
		":param str dllname: The name of the self-hosted capture module.\n"
		":return: Whether the specified dll is loaded, ready for self-hosted capture.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"StartSelfHostCapture", (PyCFunction)_wrap_StartSelfHostCapture, METH_O, (char *)"\n"
		"StartSelfHostCapture(dllname)\n"
		"\n"
		"When debugging RenderDoc it can be useful to capture itself by doing a side-build with a\n"
		"temporary name. This function wraps up the use of the in-application API to start a capture.\n"
		"\n"
		":param str dllname: The name of the self-hosted capture module.\n"
		"\n"
		""},
	 { (char *)"EndSelfHostCapture", (PyCFunction)_wrap_EndSelfHostCapture, METH_O, (char *)"\n"
		"EndSelfHostCapture(dllname)\n"
		"\n"
		"When debugging RenderDoc it can be useful to capture itself by doing a side-build with a\n"
		"temporary name. This function wraps up the use of the in-application API to end a capture.\n"
		"\n"
		":param str dllname: The name of the self-hosted capture module.\n"
		"\n"
		""},
	 { (char *)"NeedVulkanLayerRegistration", (PyCFunction)_wrap_NeedVulkanLayerRegistration, METH_O, (char *)"\n"
		"NeedVulkanLayerRegistration(info)\n"
		"\n"
		"INTERNAL: Determine vulkan layer registration status.\n"
		""},
	 { (char *)"UpdateVulkanLayerRegistration", (PyCFunction)_wrap_UpdateVulkanLayerRegistration, METH_O, (char *)"\n"
		"UpdateVulkanLayerRegistration(systemLevel)\n"
		"\n"
		"INTERNAL: Update vulkan layer registration.\n"
		""},
	 { (char *)"InitialiseReplay", _wrap_InitialiseReplay, METH_VARARGS, (char *)"\n"
		"InitialiseReplay(globalEnv, args)\n"
		"\n"
		"Initialises RenderDoc for replay. Replay API functions should not be called before this\n"
		"has been called. It should be called exactly once, and before shutdown you must call\n"
		":func:`ShutdownReplay`.\n"
		"\n"
		":param GlobalEnvironment globalEnv: The path to the new log file.\n"
		":param List[str] args: Any extra command-line arguments.\n"
		"\n"
		""},
	 { (char *)"ShutdownReplay", (PyCFunction)_wrap_ShutdownReplay, METH_NOARGS, (char *)"\n"
		"ShutdownReplay()\n"
		"\n"
		"Shutdown RenderDoc for replay. Replay API functions should not be called after this\n"
		"has been called. It is not safe to re-initialise replay after this function has been called so it\n"
		"should only be called at program shutdown. This function must only be called if\n"
		":func:`InitialiseReplay` was previously called.\n"
		"\n"
		""},
	 { (char *)"SetDebugLogFile", (PyCFunction)_wrap_SetDebugLogFile, METH_O, (char *)"\n"
		"SetDebugLogFile(filename)\n"
		"\n"
		"Sets the location for the diagnostic log output, shared by captured programs and the\n"
		"analysis program.\n"
		"\n"
		":param str filename: The path to the new log file.\n"
		"\n"
		""},
	 { (char *)"GetLogFile", (PyCFunction)_wrap_GetLogFile, METH_NOARGS, (char *)"\n"
		"GetLogFile()\n"
		"\n"
		"Gets the location for the diagnostic log output, shared by captured programs and the\n"
		"analysis program.\n"
		"\n"
		":return: The path to the current log file.\n"
		":rtype: str\n"
		"\n"
		""},
	 { (char *)"LogMessage", _wrap_LogMessage, METH_VARARGS, (char *)"\n"
		"LogMessage(type, project, file, line, text)\n"
		"\n"
		"Add a message to RenderDoc's logfile.\n"
		"\n"
		":param LogType type: The type of the log message. Error messages will trigger a debugger breakpoint\n"
		"  if a debugger is attached, and fatal errors will kill the process after logging.\n"
		":param str project: A short project tag, which should be uppercase and either 3 or 4 characters.\n"
		":param str file: The file where this log message came from.\n"
		":param int line: The line number in :paramref:`file` where this log message came from.\n"
		":param str text: The text of the message.\n"
		"\n"
		""},
	 { (char *)"GetVersionString", (PyCFunction)_wrap_GetVersionString, METH_NOARGS, (char *)"\n"
		"GetVersionString()\n"
		"\n"
		"Retrieves the version string.\n"
		"\n"
		"This will be in the form \"MAJOR.MINOR\"\n"
		"\n"
		":return: The version string.\n"
		":rtype: str\n"
		"\n"
		""},
	 { (char *)"IsReleaseBuild", (PyCFunction)_wrap_IsReleaseBuild, METH_NOARGS, (char *)"\n"
		"IsReleaseBuild()\n"
		"\n"
		"Determines if this is a release build of RenderDoc or not.\n"
		"\n"
		":return: ``True`` if the replay is running on a release build.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"GetCommitHash", (PyCFunction)_wrap_GetCommitHash, METH_NOARGS, (char *)"\n"
		"GetCommitHash()\n"
		"\n"
		"Retrieves the commit hash used to build.\n"
		"\n"
		"This will be in the form \"0123456789abcdef0123456789abcdef01234567\"\n"
		"\n"
		":return: The commit hash.\n"
		":rtype: str\n"
		"\n"
		""},
	 { (char *)"GetDriverInformation", (PyCFunction)_wrap_GetDriverInformation, METH_O, (char *)"\n"
		"GetDriverInformation(api)\n"
		"\n"
		"Retrieves the driver information (if available) for a given graphics API.\n"
		"\n"
		":param GraphicsAPI api: The API to get driver information for.\n"
		":return: A :class:`DriverInformation` containing the driver information.\n"
		":rtype: DriverInformation\n"
		"\n"
		""},
	 { (char *)"GetCurrentProcessMemoryUsage", (PyCFunction)_wrap_GetCurrentProcessMemoryUsage, METH_NOARGS, (char *)"\n"
		"GetCurrentProcessMemoryUsage()\n"
		"\n"
		"Returns the current process's memory usage in bytes\n"
		"\n"
		":return: The current memory usage in bytes.\n"
		":rtype: int\n"
		"\n"
		""},
	 { (char *)"GetConfigSetting", (PyCFunction)_wrap_GetConfigSetting, METH_O, (char *)"\n"
		"GetConfigSetting(name)\n"
		"\n"
		"Return a read-only handle to the :class:`SDObject` corresponding to a given setting's\n"
		"value object.\n"
		"\n"
		"If an empty string is passed, the root object is returned containing all settings and setting\n"
		"categories. Categories contain other categories and settings, settings contain children that include\n"
		"the setting's value, description, etc.\n"
		"\n"
		"If no such setting exists, `None` is returned.\n"
		"\n"
		":param str name: The name of the setting.\n"
		":return: The specified setting.\n"
		":rtype: SDObject\n"
		"\n"
		""},
	 { (char *)"SetConfigSetting", (PyCFunction)_wrap_SetConfigSetting, METH_O, (char *)"\n"
		"SetConfigSetting(name)\n"
		"\n"
		"Return a mutable handle to the :class:`SDObject` corresponding to a given setting's\n"
		"value object.\n"
		"\n"
		"If no such setting exists, `None` is returned.\n"
		"\n"
		":param str name: The name of the setting.\n"
		":return: The specified setting.\n"
		":rtype: SDObject\n"
		"\n"
		""},
	 { (char *)"SaveConfigSettings", (PyCFunction)_wrap_SaveConfigSettings, METH_NOARGS, (char *)"\n"
		"SaveConfigSettings()\n"
		"\n"
		"Flush the current config settings as they are in memory to the config file on disk.\n"
		"\n"
		"Without calling this function, settings changes will only be temporary. The settings are **not**\n"
		"saved to disk on exit implicitly.\n"
		"\n"
		""},
	 { (char *)"SetColors", _wrap_SetColors, METH_VARARGS, (char *)"\n"
		"SetColors(darkChecker, lightChecker, darkTheme)\n"
		"\n"
		"Configure the default colours used for checkerboards, this can broadly speaking help\n"
		"match the replay rendering to the overall theme of the replay application.\n"
		"\n"
		":param FloatVector darkChecker: The color of dark squares in checkerboard patterns.\n"
		":param FloatVector lightChecker: The color of light squares in checkerboard patterns.\n"
		":param bool darkTheme: ``True`` if the theme is a 'dark' theme, used to pick different contrasting\n"
		"  colors. ``False`` if the theme is 'light' and normal colors are used.\n"
		"\n"
		""},
	 { (char *)"CheckAndroidPackage", _wrap_CheckAndroidPackage, METH_VARARGS, (char *)"\n"
		"CheckAndroidPackage(URL, packageAndActivity, flags)\n"
		"\n"
		"INTERNAL: Check remote Android package for requirements\n"
		""},
	 { (char *)"GetSupportedDeviceProtocols", (PyCFunction)_wrap_GetSupportedDeviceProtocols, METH_NOARGS, (char *)"\n"
		"GetSupportedDeviceProtocols()\n"
		"\n"
		"Retrieve the set of device protocols supported (see :func:`GetDeviceProtocolController`).\n"
		"\n"
		":return: The supported device protocols.\n"
		":rtype: List[str]\n"
		"\n"
		""},
	 { (char *)"GetDeviceProtocolController", (PyCFunction)_wrap_GetDeviceProtocolController, METH_O, (char *)"\n"
		"GetDeviceProtocolController(protocol)\n"
		"\n"
		"Creates a :class:`DeviceProtocolController` that provides device-specific controls.\n"
		"\n"
		"This interface is intended to allow closer integration with remote devices.\n"
		"\n"
		".. note::\n"
		"  Note that the use of scripting with Android is explicitly **not supported** due to the inherent\n"
		"  fragility and unreliability of the Android platform. This interface is designed primarily for\n"
		"  internal use and no support will be provided for Android-specific problems encountered using this.\n"
		"\n"
		"This function will not block, however the protocol may still be initialising when it is returned so\n"
		"immediate use of it may block.\n"
		"\n"
		":param str protocol: The protocol to fetch a controller for.\n"
		":return: A handle to the protocol controller, or ``None`` if something went wrong such as an\n"
		"  unsupported protocol being specified.\n"
		":rtype: DeviceProtocolController\n"
		"\n"
		""},
	 { (char *)"ResourceId_Null", (PyCFunction)_wrap_ResourceId_Null, METH_NOARGS, (char *)"\n"
		"ResourceId_Null()\n"
		"\n"
		"A helper function that explicitly creates an empty/invalid/null :class:`ResourceId`.\n"
		"\n"
		":return: an empty/invalid/null :class:`ResourceId`.\n"
		":rtype: ResourceId\n"
		"\n"
		""},
	 { (char *)"makeSDInt64", _wrap_makeSDInt64, METH_VARARGS, (char *)"\n"
		"makeSDInt64(name, val)\n"
		"\n"
		"Make a structured object as a signed 64-bit integer.\n"
		"\n"
		".. note::\n"
		"  You should ensure that the value you pass in has already been truncated to the appropriate range\n"
		"  for the storage, as the resulting object will be undefined if the value is out of the valid range.\n"
		"\n"
		":param str name: The name of the object.\n"
		":param int val: The integer which will be stored in the returned object.\n"
		":return: The new object, owner by the caller.\n"
		":rtype: SDObject\n"
		"\n"
		""},
	 { (char *)"makeSDUInt64", _wrap_makeSDUInt64, METH_VARARGS, (char *)"\n"
		"makeSDUInt64(name, val)\n"
		"\n"
		"Make a structured object as an unsigned 64-bit integer.\n"
		"\n"
		".. note::\n"
		"  You should ensure that the value you pass in has already been truncated to the appropriate range\n"
		"  for the storage, as the resulting object will be undefined if the value is out of the valid range.\n"
		"\n"
		":param str name: The name of the object.\n"
		":param int val: The integer which will be stored in the returned object.\n"
		":return: The new object, owner by the caller.\n"
		":rtype: SDObject\n"
		"\n"
		""},
	 { (char *)"makeSDInt32", _wrap_makeSDInt32, METH_VARARGS, (char *)"\n"
		"makeSDInt32(name, val)\n"
		"\n"
		"Make a structured object as a signed 32-bit integer.\n"
		"\n"
		".. note::\n"
		"  You should ensure that the value you pass in has already been truncated to the appropriate range\n"
		"  for the storage, as the resulting object will be undefined if the value is out of the valid range.\n"
		"\n"
		":param str name: The name of the object.\n"
		":param int val: The integer which will be stored in the returned object.\n"
		":return: The new object, owner by the caller.\n"
		":rtype: SDObject\n"
		"\n"
		""},
	 { (char *)"makeSDUInt32", _wrap_makeSDUInt32, METH_VARARGS, (char *)"\n"
		"makeSDUInt32(name, val)\n"
		"\n"
		"Make a structured object as an unsigned 32-bit integer.\n"
		"\n"
		".. note::\n"
		"  You should ensure that the value you pass in has already been truncated to the appropriate range\n"
		"  for the storage, as the resulting object will be undefined if the value is out of the valid range.\n"
		"\n"
		":param str name: The name of the object.\n"
		":param int val: The integer which will be stored in the returned object.\n"
		":return: The new object, owner by the caller.\n"
		":rtype: SDObject\n"
		"\n"
		""},
	 { (char *)"makeSDFloat", _wrap_makeSDFloat, METH_VARARGS, (char *)"\n"
		"makeSDFloat(name, val)\n"
		"\n"
		"Make a structured object as a 32-bit float.\n"
		"\n"
		".. note::\n"
		"  You should ensure that the value you pass in has already been truncated to the appropriate range\n"
		"  for the storage, as the resulting object will be undefined if the value is out of the valid range.\n"
		"\n"
		":param str name: The name of the object.\n"
		":param float val: The float which will be stored in the returned object.\n"
		":return: The new object, owner by the caller.\n"
		":rtype: SDObject\n"
		"\n"
		""},
	 { (char *)"makeSDBool", _wrap_makeSDBool, METH_VARARGS, (char *)"\n"
		"makeSDBool(name, val)\n"
		"\n"
		"Make a structured object as a boolean value.\n"
		"\n"
		":param str name: The name of the object.\n"
		":param bool val: The bool which will be stored in the returned object.\n"
		":return: The new object, owner by the caller.\n"
		":rtype: SDObject\n"
		"\n"
		""},
	 { (char *)"makeSDString", _wrap_makeSDString, METH_VARARGS, (char *)"\n"
		"makeSDString(name, val)\n"
		"\n"
		"Make a structured object as a string value.\n"
		"\n"
		":param str name: The name of the object.\n"
		":param str val: The string which will be stored in the returned object.\n"
		":return: The new object, owner by the caller.\n"
		":rtype: SDObject\n"
		"\n"
		""},
	 { (char *)"makeSDResourceId", _wrap_makeSDResourceId, METH_VARARGS, (char *)"\n"
		"makeSDResourceId(name, val)\n"
		"\n"
		"Make a structured object as a ResourceId value.\n"
		"\n"
		":param str name: The name of the object.\n"
		":param ResourceId val: The ID which will be stored in the returned object.\n"
		":return: The new object, owner by the caller.\n"
		":rtype: SDObject\n"
		"\n"
		""},
	 { (char *)"makeSDEnum", _wrap_makeSDEnum, METH_VARARGS, (char *)"\n"
		"makeSDEnum(name, val)\n"
		"\n"
		"Make a structured object as an enum value.\n"
		"\n"
		".. note::\n"
		"  The enum will be stored just as an integer value, but the string name of the enumeration value can\n"
		"  be set with :meth:`SDObject.SetCustomString` if desired.\n"
		"\n"
		":param str name: The name of the object.\n"
		":param int val: The integer value of the enum itself.\n"
		":return: The new object, owner by the caller.\n"
		":rtype: SDObject\n"
		"\n"
		""},
	 { (char *)"makeSDArray", (PyCFunction)_wrap_makeSDArray, METH_O, (char *)"\n"
		"makeSDArray(name)\n"
		"\n"
		"Make a structured object which is an array.\n"
		"\n"
		"The array will be created empty, and new members can be added using methods on :class:`SDObject`.\n"
		"\n"
		":param str name: The name of the object.\n"
		":return: The new object, owner by the caller.\n"
		":rtype: SDObject\n"
		"\n"
		""},
	 { (char *)"makeSDStruct", _wrap_makeSDStruct, METH_VARARGS, (char *)"\n"
		"makeSDStruct(name, structtype)\n"
		"\n"
		"Make a structured object which is a struct.\n"
		"\n"
		"The struct will be created empty, and new members can be added using methods on :class:`SDObject`.\n"
		"\n"
		":param str name: The name of the object.\n"
		":param str structtype: The typename of the struct.\n"
		":return: The new object, owner by the caller.\n"
		":rtype: SDObject\n"
		"\n"
		""},
	 { (char *)"VarTypeByteSize", (PyCFunction)_wrap_VarTypeByteSize, METH_O, (char *)"\n"
		"VarTypeByteSize(type)\n"
		"\n"
		"Get the byte size of a variable type.\n"
		"\n"
		":param VarType type: The variable type\n"
		":return: The size in bytes of this type\n"
		":rtype: int\n"
		"\n"
		""},
	 { (char *)"VarTypeCompType", (PyCFunction)_wrap_VarTypeCompType, METH_O, (char *)"\n"
		"VarTypeCompType(type)\n"
		"\n"
		"Get the component type of a variable type.\n"
		"\n"
		":param VarType type: The variable type\n"
		":return: The base component type of this variable type\n"
		":rtype: CompType\n"
		"\n"
		""},
	 { (char *)"CategoryForDescriptorType", (PyCFunction)_wrap_CategoryForDescriptorType, METH_O, (char *)"\n"
		"CategoryForDescriptorType(type)\n"
		"\n"
		"Get the shader interface category for a given type of descriptor.\n"
		"\n"
		":param DescriptorType type: The type of descriptor\n"
		":return: The descriptor category.\n"
		":rtype: DescriptorCategory\n"
		"\n"
		""},
	 { (char *)"IsConstantBlockDescriptor", (PyCFunction)_wrap_IsConstantBlockDescriptor, METH_O, (char *)"\n"
		"IsConstantBlockDescriptor(type)\n"
		"\n"
		"Checks if a descriptor type corresponds to a constant block in shader reflection.\n"
		"\n"
		":param DescriptorType type: The type of descriptor\n"
		":return: ``True`` if the descriptor type is a constant block descriptor.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"IsSamplerDescriptor", (PyCFunction)_wrap_IsSamplerDescriptor, METH_O, (char *)"\n"
		"IsSamplerDescriptor(type)\n"
		"\n"
		"Checks if a descriptor type corresponds to a sampler in shader reflection. Only dedicated\n"
		"sampler types are sampler descriptors, combined image/samplers are reported only as read only\n"
		"resources.\n"
		"\n"
		":param DescriptorType type: The type of descriptor\n"
		":return: ``True`` if the descriptor type is a sampler descriptor.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"IsReadOnlyDescriptor", (PyCFunction)_wrap_IsReadOnlyDescriptor, METH_O, (char *)"\n"
		"IsReadOnlyDescriptor(type)\n"
		"\n"
		"Checks if a descriptor type corresponds to a read only resource in shader reflection.\n"
		"Combined image/samplers are reported as read only resources.\n"
		"\n"
		":param DescriptorType type: The type of descriptor\n"
		":return: ``True`` if the descriptor type is a read-only resource descriptor.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"IsReadWriteDescriptor", (PyCFunction)_wrap_IsReadWriteDescriptor, METH_O, (char *)"\n"
		"IsReadWriteDescriptor(type)\n"
		"\n"
		"Checks if a descriptor type corresponds to a read write resource in shader reflection.\n"
		"\n"
		":param DescriptorType type: The type of descriptor\n"
		":return: ``True`` if the descriptor type is a read-write resource descriptor.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"GPUVendorFromPCIVendor", (PyCFunction)_wrap_GPUVendorFromPCIVendor, METH_O, (char *)"\n"
		"GPUVendorFromPCIVendor(vendorID)\n"
		"\n"
		"Get the GPUVendor for a given PCI Vendor ID.\n"
		"\n"
		":param int vendorID: The PCI Vendor ID\n"
		":return: The vendor identified\n"
		":rtype: GPUVendor\n"
		"\n"
		""},
	 { (char *)"IsD3D", (PyCFunction)_wrap_IsD3D, METH_O, (char *)"\n"
		"IsD3D(api)\n"
		"\n"
		"Check if an API is D3D or not\n"
		"\n"
		":param GraphicsAPI api: The graphics API in question\n"
		":return: ``True`` if api is a D3D-based API, ``False`` otherwise\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"ToolExecutable", (PyCFunction)_wrap_ToolExecutable, METH_O, (char *)"\n"
		"ToolExecutable(tool)\n"
		"\n"
		"Returns the default executable name with no suffix for a given :class:`KnownShaderTool`.\n"
		"\n"
		".. note::\n"
		"  The executable name is returned with no suffix, e.g. ``foobar`` which may need a platform specific\n"
		"  suffix like ``.exe`` appended.\n"
		"\n"
		":param KnownShaderTool tool: The tool to get the executable name for.\n"
		":return: The default executable name for this tool, or an empty string if the tool is unrecognised.\n"
		":rtype: str\n"
		"\n"
		""},
	 { (char *)"ToolInput", (PyCFunction)_wrap_ToolInput, METH_O, (char *)"\n"
		"ToolInput(tool)\n"
		"\n"
		"Returns the expected default input :class:`~renderdoc.ShaderEncoding` that a\n"
		":class:`KnownShaderTool` expects. This may not be accurate and may be configurable depending on the\n"
		"tool.\n"
		"\n"
		":param KnownShaderTool tool: The tool to get the input encoding for.\n"
		":return: The encoding that this tool expects as an input by default.\n"
		":rtype: ShaderEncoding\n"
		"\n"
		""},
	 { (char *)"ToolOutput", (PyCFunction)_wrap_ToolOutput, METH_O, (char *)"\n"
		"ToolOutput(tool)\n"
		"\n"
		"Returns the expected default output :class:`~renderdoc.ShaderEncoding` that a\n"
		":class:`KnownShaderTool` produces. This may not be accurate and may be configurable depending on the\n"
		"tool.\n"
		"\n"
		":param KnownShaderTool tool: The tool to get the output encoding for.\n"
		":return: The encoding that this tool produces as an output by default.\n"
		":rtype: ShaderEncoding\n"
		"\n"
		""},
	 { (char *)"IsTextRepresentation", (PyCFunction)_wrap_IsTextRepresentation, METH_O, (char *)"\n"
		"IsTextRepresentation(encoding)\n"
		"\n"
		"Check whether or not this is a human readable text representation.\n"
		"\n"
		":param ShaderEncoding encoding: The encoding to check.\n"
		":return: ``True`` if it describes a text representation, ``False`` for a bytecode representation.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"PatchList_Topology", (PyCFunction)_wrap_PatchList_Topology, METH_O, (char *)"\n"
		"PatchList_Topology(N)\n"
		"\n"
		"Return the patch list ``Topology`` with N control points\n"
		"\n"
		"``N`` must be between 1 and 32 inclusive.\n"
		"\n"
		":param int N: The number of control points in the patch list\n"
		":return: The patchlist topology with that number of control points\n"
		":rtype: Topology\n"
		"\n"
		""},
	 { (char *)"PatchList_Count", (PyCFunction)_wrap_PatchList_Count, METH_O, (char *)"\n"
		"PatchList_Count(topology)\n"
		"\n"
		"Return the number of control points in a patch list ``Topology``\n"
		"\n"
		"``t`` must be a patch list topology, the return value will be between 1 and 32 inclusive\n"
		"\n"
		":param Topology topology: The patch list topology\n"
		":return: The number of control points in the specified topology\n"
		":rtype: int\n"
		"\n"
		""},
	 { (char *)"IsStrip", (PyCFunction)_wrap_IsStrip, METH_O, (char *)"\n"
		"IsStrip(topology)\n"
		"\n"
		"Check whether or not this is a strip-type topology.\n"
		"\n"
		":param Topology topology: The topology to check.\n"
		":return: ``True`` if it describes a strip topology, ``False`` for a list.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"CBUsage", (PyCFunction)_wrap_CBUsage, METH_O, (char *)"\n"
		"CBUsage(stage)\n"
		"\n"
		"Calculate the ``ResourceUsage`` value for constant buffer use at a given shader stage.\n"
		"\n"
		":param ShaderStage stage: The shader stage.\n"
		":return: The value for constant buffer usage at a given shader stage.\n"
		":rtype: ResourceUsage\n"
		"\n"
		""},
	 { (char *)"ResUsage", (PyCFunction)_wrap_ResUsage, METH_O, (char *)"\n"
		"ResUsage(stage)\n"
		"\n"
		"Calculate the ``ResourceUsage`` value for read-only resource use at a given shader\n"
		"stage.\n"
		"\n"
		":param ShaderStage stage: The shader stage.\n"
		":return: The value for read-only resource usage at a given shader stage.\n"
		":rtype: ResourceUsage\n"
		"\n"
		""},
	 { (char *)"RWResUsage", (PyCFunction)_wrap_RWResUsage, METH_O, (char *)"\n"
		"RWResUsage(stage)\n"
		"\n"
		"Calculate the ``ResourceUsage`` value for read-write resource use at a given shader\n"
		"stage.\n"
		"\n"
		":param ShaderStage stage: The shader stage.\n"
		":return: The value for read-write resource usage at a given shader stage.\n"
		":rtype: ResourceUsage\n"
		"\n"
		""},
	 { (char *)"IsGenericCounter", (PyCFunction)_wrap_IsGenericCounter, METH_O, (char *)"\n"
		"IsGenericCounter(c)\n"
		"\n"
		"Check whether or not this is a Generic counter.\n"
		"\n"
		":param GPUCounter c: The counter.\n"
		":return: ``True`` if it is a generic counter, ``False`` if it's not.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"IsAMDCounter", (PyCFunction)_wrap_IsAMDCounter, METH_O, (char *)"\n"
		"IsAMDCounter(c)\n"
		"\n"
		"Check whether or not this is an AMD private counter.\n"
		"\n"
		":param GPUCounter c: The counter.\n"
		":return: ``True`` if it is an AMD private counter, ``False`` if it's not.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"IsIntelCounter", (PyCFunction)_wrap_IsIntelCounter, METH_O, (char *)"\n"
		"IsIntelCounter(c)\n"
		"\n"
		"Check whether or not this is an Intel private counter.\n"
		"\n"
		":param GPUCounter c: The counter.\n"
		":return: ``True`` if it is an Intel private counter, ``False`` if it's not.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"IsNvidiaCounter", (PyCFunction)_wrap_IsNvidiaCounter, METH_O, (char *)"\n"
		"IsNvidiaCounter(c)\n"
		"\n"
		"Check whether or not this is an Nvidia private counter.\n"
		"\n"
		":param GPUCounter c: The counter.\n"
		":return: ``True`` if it is an Nvidia private counter, ``False`` if it's not.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"IsVulkanExtendedCounter", (PyCFunction)_wrap_IsVulkanExtendedCounter, METH_O, (char *)"\n"
		"IsVulkanExtendedCounter(c)\n"
		"\n"
		"Check whether or not this is a KHR counter.\n"
		"\n"
		":param GPUCounter c: The counter.\n"
		":return: ``True`` if it is a Vulkan counter reported through the VK_KHR_performance_query extension, ``False`` if it's not.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"IsARMCounter", (PyCFunction)_wrap_IsARMCounter, METH_O, (char *)"\n"
		"IsARMCounter(c)\n"
		"\n"
		"Check whether or not this is an ARM private counter.\n"
		"\n"
		":param GPUCounter c: The counter.\n"
		":return: ``True`` if it is an ARM private counter, ``False`` if it's not.\n"
		":rtype: bool\n"
		"\n"
		""},
	 { (char *)"MaskForStage", (PyCFunction)_wrap_MaskForStage, METH_O, (char *)"\n"
		"MaskForStage(stage)\n"
		"\n"
		"Calculate the corresponding flag for a shader stage\n"
		"\n"
		":param ShaderStage stage: The shader stage\n"
		":return: The flag that corresponds to the input shader stage\n"
		":rtype: ShaderStageMask\n"
		"\n"
		""},
	 { (char *)"FirstStageForMask", (PyCFunction)_wrap_FirstStageForMask, METH_O, (char *)"\n"
		"FirstStageForMask(stageMask)\n"
		"\n"
		"For a shader stage mask that only covers one shader stage, return the shader stage.\n"
		"\n"
		".. note::\n"
		"  If the shader stage mask covers multiple stages, only the first matching stage will be returned.\n"
		"  If the mask is empty, :data:`ShaderStage.Count` will be returned.\n"
		"\n"
		":param ShaderStageMask stageMask: The shader stage mask.\n"
		":return: The first shader stage covered by the mask.\n"
		":rtype: ShaderStage\n"
		"\n"
		""},
	 { (char *)"DumpObject", (PyCFunction)_wrap_DumpObject, METH_O, (char *)"\n"
		"DumpObject(obj)\n"
		"\n"
		"Returns a string representation of an object. This is quite similar to\n"
		"the built-in repr() function but it iterates over struct members and prints them out, where normally\n"
		"repr() would stop and say something like 'Swig Object of type ...'.\n"
		"\n"
		":param Any obj: The object to dump\n"
		":return: The string representation of the object.\n"
		":rtype: str\n"
		"\n"
		""},
	 { NULL, NULL, 0, NULL }
};

static SwigPyGetSet ReplayOutput___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__IReplayOutput_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"IReplayOutput.__dict__", (void *) &ReplayOutput___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__IReplayOutput_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__IReplayOutput_methods[] = {
  { "Shutdown", (PyCFunction) _wrap_ReplayOutput_Shutdown, METH_NOARGS, (char *) "\n"
		"Shutdown()\n"
		"\n"
		"Shutdown this output.\n"
		"\n"
		"It's optional to call this, as calling :meth:`ReplayController.Shutdown` will shut down all of its\n"
		"outputs.\n"
		"\n"
		"" },
  { "SetTextureDisplay", (PyCFunction) _wrap_ReplayOutput_SetTextureDisplay, METH_O, (char *) "\n"
		"SetTextureDisplay(config)\n"
		"\n"
		"Sets the configuration for a texture output.\n"
		"\n"
		":param TextureDisplay config: The configuration.\n"
		"\n"
		"" },
  { "SetMeshDisplay", (PyCFunction) _wrap_ReplayOutput_SetMeshDisplay, METH_O, (char *) "\n"
		"SetMeshDisplay(config)\n"
		"\n"
		"Sets the configuration for a mesh output.\n"
		"\n"
		":param MeshDisplay config: The configuration.\n"
		"\n"
		"" },
  { "ReadbackOutputTexture", (PyCFunction) _wrap_ReplayOutput_ReadbackOutputTexture, METH_NOARGS, (char *) "\n"
		"ReadbackOutputTexture()\n"
		"\n"
		"Read the output texture back as byte data. Primarily useful for headless outputs where\n"
		"the output data is not displayed anywhere natively.\n"
		"\n"
		":return: The output texture data as tightly packed RGB 3-byte data.\n"
		":rtype: bytes\n"
		"\n"
		"" },
  { "GetDimensions", (PyCFunction) _wrap_ReplayOutput_GetDimensions, METH_NOARGS, (char *) "\n"
		"GetDimensions()\n"
		"\n"
		"Retrieve the current dimensions of the output.\n"
		"\n"
		":return: The current width and height of the output.\n"
		":rtype: Tuple[int,int]\n"
		"\n"
		"" },
  { "ClearThumbnails", (PyCFunction) _wrap_ReplayOutput_ClearThumbnails, METH_NOARGS, (char *) "\n"
		"ClearThumbnails()\n"
		"\n"
		"Clear and release all thumbnails associated with this output. See :meth:`AddThumbnail`.\n"
		"" },
  { "AddThumbnail", (PyCFunction) _wrap_ReplayOutput_AddThumbnail, METH_VARARGS, (char *) "\n"
		"AddThumbnail(window, textureId, sub, typeCast)\n"
		"\n"
		"Sets up a thumbnail for displaying a particular texture with sensible defaults.\n"
		"\n"
		"The window handle specified will be filled (in an aspect-ratio preserving way) with the texture.\n"
		"\n"
		"If the window specified has been used for a thumbnail before, then the texture will be updated but\n"
		"otherwise nothing will be created and the existing internal data will be reused. This means that\n"
		"you can call this function multiple times to just change the texture.\n"
		"\n"
		"Should only be called for texture outputs.\n"
		"\n"
		":param WindowingData window: A :class:`WindowingData` describing the native window.\n"
		":param ResourceId textureId: The texture ID to display in the thumbnail preview.\n"
		":param Subresource sub: The subresource within this texture to use.\n"
		":param CompType typeCast: If possible interpret the texture with this type instead of its normal\n"
		"  type. If set to :data:`CompType.Typeless` then no cast is applied, otherwise where allowed the\n"
		"  texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned\n"
		"  normalised values.\n"
		":return: A result indicating if the thumbnail was successfully created.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { "DrawThumbnail", (PyCFunction) _wrap_ReplayOutput_DrawThumbnail, METH_VARARGS, (char *) "\n"
		"DrawThumbnail(width, height, textureId, sub, typeCast)\n"
		"\n"
		"Draws a thumbnail for a particular texture with sensible defaults and returns an RGBA8\n"
		"byte buffer for display. This does not render to a window but internally to a texture which is read\n"
		"back from the GPU.\n"
		"\n"
		"Should only be called for texture outputs.\n"
		"\n"
		":param int width: The width of the desired thumbnail.\n"
		":param int height: The height of the desired thumbnail.\n"
		":param ResourceId textureId: The texture ID to display in the thumbnail preview.\n"
		":param Subresource sub: The subresource within this texture to use.\n"
		":param CompType typeCast: If possible interpret the texture with this type instead of its normal\n"
		"  type. If set to :data:`CompType.Typeless` then no cast is applied, otherwise where allowed the\n"
		"  texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned\n"
		"  normalised values.\n"
		":return: A buffer with the thumbnail RGBA8 data if successful, or empty if something went wrong.\n"
		":rtype: bytes\n"
		"\n"
		"" },
  { "Display", (PyCFunction) _wrap_ReplayOutput_Display, METH_NOARGS, (char *) "\n"
		"Display()\n"
		"\n"
		"Render to the window handle specified when the output was created.\n"
		"\n"
		"This will also render any thumbnails and the pixel context, if enabled.\n"
		"\n"
		"" },
  { "SetPixelContext", (PyCFunction) _wrap_ReplayOutput_SetPixelContext, METH_O, (char *) "\n"
		"SetPixelContext(window)\n"
		"\n"
		"Sets up a zoomed in pixel context view around a particular pixel selection.\n"
		"\n"
		"The texture rendering uses the configuration specified in :meth:`SetTextureDisplay` except with a\n"
		"fixed high zoom value and a fixed position, see :meth:`SetPixelContextLocation`.\n"
		"\n"
		"Should only be called for texture outputs.\n"
		"\n"
		":param WindowingData window: A :class:`WindowingData` describing the native window.\n"
		":return: A result indicating if the pixel context was successfully configured.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { "SetPixelContextLocation", (PyCFunction) _wrap_ReplayOutput_SetPixelContextLocation, METH_VARARGS, (char *) "\n"
		"SetPixelContextLocation(x, y)\n"
		"\n"
		"Sets the pixel that the pixel context should be centred on.\n"
		"\n"
		"Should only be called for texture outputs.\n"
		"\n"
		":param int x: The X co-ordinate to highlight.\n"
		":param int y: The Y co-ordinate to highlight.\n"
		"\n"
		"" },
  { "DisablePixelContext", (PyCFunction) _wrap_ReplayOutput_DisablePixelContext, METH_NOARGS, (char *) "\n"
		"DisablePixelContext()\n"
		"\n"
		"Disable the pixel context view from rendering.\n"
		"" },
  { "GetCustomShaderTexID", (PyCFunction) _wrap_ReplayOutput_GetCustomShaderTexID, METH_NOARGS, (char *) "\n"
		"GetCustomShaderTexID()\n"
		"\n"
		"Retrieves the :class:`ResourceId` containing the contents of the texture after being\n"
		"passed through a custom shader pass.\n"
		"\n"
		"Should only be called for texture outputs.\n"
		"\n"
		":return: The :class:`ResourceId` assigned to the texture with the results of the custom shader.\n"
		":rtype: ResourceId\n"
		"\n"
		"" },
  { "GetDebugOverlayTexID", (PyCFunction) _wrap_ReplayOutput_GetDebugOverlayTexID, METH_NOARGS, (char *) "\n"
		"GetDebugOverlayTexID()\n"
		"\n"
		"Retrieves the :class:`ResourceId` containing the contents of the debug overlay\n"
		"rendering (if enabled).\n"
		"\n"
		"Should only be called for texture outputs.\n"
		"\n"
		":return: The :class:`ResourceId` assigned to the texture with the debug overlay.\n"
		":rtype: ResourceId\n"
		"\n"
		"" },
  { "PickVertex", (PyCFunction) _wrap_ReplayOutput_PickVertex, METH_VARARGS, (char *) "\n"
		"PickVertex(x, y)\n"
		"\n"
		"Retrieves the vertex and instance that is under the cursor location, when viewed\n"
		"relative to the current window with the current mesh display configuration.\n"
		"\n"
		".. note::\n"
		"  X and Y co-ordinates are always considered to be top-left, even on GL, for consistency between\n"
		"  APIs and preventing the need for API-specific code in most cases. This means if co-ordinates are\n"
		"  fetched from e.g. viewport or scissor data or other GL pipeline state which is perhaps in\n"
		"  bottom-left co-ordinates, care must be taken to translate them.\n"
		"\n"
		"Should only be called for mesh outputs.\n"
		"\n"
		":param int x: The x co-ordinate to pick from.\n"
		":param int y: The y co-ordinate to pick from.\n"
		":return: A tuple with the first value being the vertex index in the mesh, and the second value being\n"
		"  the instance index. The values are set to :data:`NoResult` if no vertex was found, \n"
		":rtype: Tuple[int,int]\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__IReplayOutput_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ReplayOutput",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__IReplayOutput_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__IReplayOutput_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__IReplayOutput_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__IReplayOutput_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A stateful output handle that contains the current configuration for one particular view\n"
		"of the capture. This allows multiple outputs to run independently without interfering with each\n"
		"other.\n"
		"\n"
		"The different types are enumerated in :class:`ReplayOutputType`.\n"
		"\n"
		".. data:: NoResult\n"
		"\n"
		"  No result was found in e.g. :meth:`PickVertex`.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__IReplayOutput_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__IReplayOutput_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__IReplayOutput_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__IReplayOutput_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__IReplayOutput_type};

static SwigPyGetSet ReplayController___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__IReplayController_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"IReplayController.__dict__", (void *) &ReplayController___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__IReplayController_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__IReplayController_methods[] = {
  { "GetAPIProperties", (PyCFunction) _wrap_ReplayController_GetAPIProperties, METH_NOARGS, (char *) "\n"
		"GetAPIProperties()\n"
		"\n"
		"Retrieve a :class:`APIProperties` object describing the current capture.\n"
		"\n"
		":return: The properties of the current capture.\n"
		":rtype: APIProperties\n"
		"\n"
		"" },
  { "GetSupportedWindowSystems", (PyCFunction) _wrap_ReplayController_GetSupportedWindowSystems, METH_NOARGS, (char *) "\n"
		"GetSupportedWindowSystems()\n"
		"\n"
		"Retrieves the supported :class:`WindowingSystem` systems by the local system.\n"
		"\n"
		":return: The list of supported systems.\n"
		":rtype: List[WindowingSystem]\n"
		"\n"
		"" },
  { "CreateOutput", (PyCFunction) _wrap_ReplayController_CreateOutput, METH_VARARGS, (char *) "\n"
		"CreateOutput(window, type)\n"
		"\n"
		"Creates a replay output of the given type to the given native window\n"
		"\n"
		":param WindowingData window: A :class:`WindowingData` describing the native window.\n"
		":param ReplayOutputType type: What type of output to create\n"
		":return: A handle to the created output, or ``None`` on failure\n"
		":rtype: ReplayOutput\n"
		"\n"
		"" },
  { "Shutdown", (PyCFunction) _wrap_ReplayController_Shutdown, METH_NOARGS, (char *) "\n"
		"Shutdown()\n"
		"\n"
		"Shutdown and destroy the current interface and all outputs that have been created.\n"
		"" },
  { "ReplayLoop", (PyCFunction) _wrap_ReplayController_ReplayLoop, METH_VARARGS, (char *) "\n"
		"ReplayLoop(window, texid)\n"
		"\n"
		"Goes into a blocking loop, repeatedly replaying the open capture as fast as possible,\n"
		"displaying the selected texture in a default unscaled manner to the given output window.\n"
		"\n"
		"The function won't return until :meth:`CancelReplayLoop` is called. Since this function is blocking, that\n"
		"function must be called from another thread.\n"
		"\n"
		":param WindowingData window: A :class:`WindowingData` describing the native window.\n"
		":param ResourceId texid: The id of the texture to display.\n"
		"\n"
		"" },
  { "CreateRGPProfile", (PyCFunction) _wrap_ReplayController_CreateRGPProfile, METH_O, (char *) "\n"
		"CreateRGPProfile(window)\n"
		"\n"
		"Uses the given output window to create an RGP Profile.\n"
		"\n"
		":param WindowingData window: A :class:`WindowingData` describing the native window.\n"
		":return: The path to the created RGP profile, or empty on failure\n"
		":rtype: str\n"
		"\n"
		"" },
  { "CancelReplayLoop", (PyCFunction) _wrap_ReplayController_CancelReplayLoop, METH_NOARGS, (char *) "\n"
		"CancelReplayLoop()\n"
		"\n"
		"Cancels a replay loop begun in :meth:`ReplayLoop`. Does nothing if no loop is active.\n"
		"" },
  { "FileChanged", (PyCFunction) _wrap_ReplayController_FileChanged, METH_NOARGS, (char *) "\n"
		"FileChanged()\n"
		"\n"
		"Notify the interface that the file it has open has been changed on disk.\n"
		"" },
  { "SetFrameEvent", (PyCFunction) _wrap_ReplayController_SetFrameEvent, METH_VARARGS, (char *) "\n"
		"SetFrameEvent(eventId, force)\n"
		"\n"
		"Move the replay to reflect the state immediately *after* the given\n"
		":data:`eventId <APIEvent.eventId>`.\n"
		"\n"
		":param int eventId: The :data:`eventId <APIEvent.eventId>` to move to.\n"
		":param bool force: ``True`` if the internal replay should refresh even if the ``eventId`` is\n"
		"  already current. This can be useful if external factors might cause the replay to vary.\n"
		"\n"
		"" },
  { "GetD3D11PipelineState", (PyCFunction) _wrap_ReplayController_GetD3D11PipelineState, METH_NOARGS, (char *) "\n"
		"GetD3D11PipelineState()\n"
		"\n"
		"Retrieve the current :class:`D3D11State` pipeline state.\n"
		"\n"
		"The return value will be ``None`` if the capture is not using the D3D11 API.\n"
		"You should use :meth:`GetAPIProperties` to determine the API of the capture.\n"
		"\n"
		"See also :meth:`GetPipelineState`.\n"
		"\n"
		":return: The current D3D11 pipeline state.\n"
		":rtype: D3D11State\n"
		"\n"
		"" },
  { "GetD3D12PipelineState", (PyCFunction) _wrap_ReplayController_GetD3D12PipelineState, METH_NOARGS, (char *) "\n"
		"GetD3D12PipelineState()\n"
		"\n"
		"Retrieve the current :class:`D3D12State` pipeline state.\n"
		"\n"
		"The return value will be ``None`` if the capture is not using the D3D12 API.\n"
		"You should use :meth:`GetAPIProperties` to determine the API of the capture.\n"
		"\n"
		"See also :meth:`GetPipelineState`.\n"
		"\n"
		":return: The current D3D12 pipeline state.\n"
		":rtype: D3D12State\n"
		"\n"
		"" },
  { "GetGLPipelineState", (PyCFunction) _wrap_ReplayController_GetGLPipelineState, METH_NOARGS, (char *) "\n"
		"GetGLPipelineState()\n"
		"\n"
		"Retrieve the current :class:`GLState` pipeline state.\n"
		"\n"
		"The return value will be ``None`` if the capture is not using the OpenGL API.\n"
		"You should use :meth:`GetAPIProperties` to determine the API of the capture.\n"
		"\n"
		"See also :meth:`GetPipelineState`.\n"
		"\n"
		":return: The current OpenGL pipeline state.\n"
		":rtype: GLState\n"
		"\n"
		"" },
  { "GetVulkanPipelineState", (PyCFunction) _wrap_ReplayController_GetVulkanPipelineState, METH_NOARGS, (char *) "\n"
		"GetVulkanPipelineState()\n"
		"\n"
		"Retrieve the current :class:`VKState` pipeline state.\n"
		"\n"
		"The return value will be ``None`` if the capture is not using the Vulkan API.\n"
		"You should use :meth:`GetAPIProperties` to determine the API of the capture.\n"
		"\n"
		"See also :meth:`GetPipelineState`.\n"
		"\n"
		":return: The current Vulkan pipeline state.\n"
		":rtype: VKState\n"
		"\n"
		"" },
  { "GetPipelineState", (PyCFunction) _wrap_ReplayController_GetPipelineState, METH_NOARGS, (char *) "\n"
		"GetPipelineState()\n"
		"\n"
		"Retrieve the current :class:`PipeState` pipeline state abstraction.\n"
		"\n"
		"This pipeline state will always be valid, and allows queries that will work regardless of the\n"
		"capture's API.\n"
		"\n"
		":return: The current pipeline state abstraction.\n"
		":rtype: PipeState\n"
		"\n"
		"" },
  { "GetDescriptors", (PyCFunction) _wrap_ReplayController_GetDescriptors, METH_VARARGS, (char *) "\n"
		"GetDescriptors(descriptorStore, ranges)\n"
		"\n"
		"Retrieve the contents of a number of descriptors in a descriptor store. Multiple\n"
		"ranges within the store can be queried at once, and are returned in a contiguous array.\n"
		"\n"
		":param ResourceId descriptorStore: The descriptor store to be queried from.\n"
		":param List[DescriptorRange] ranges: The descriptor ranges to query.\n"
		":return: The contents of the descriptors specified.\n"
		":rtype: List[Descriptor]\n"
		"\n"
		"" },
  { "GetSamplerDescriptors", (PyCFunction) _wrap_ReplayController_GetSamplerDescriptors, METH_VARARGS, (char *) "\n"
		"GetSamplerDescriptors(descriptorStore, ranges)\n"
		"\n"
		"Retrieve the contents of a number of sampler descriptors in a descriptor store.\n"
		"Multiple ranges within the store can be queried at once, and are returned in a contiguous array.\n"
		"\n"
		":param ResourceId descriptorStore: The descriptor store to be queried from.\n"
		":param List[DescriptorRange] ranges: The descriptor ranges to query.\n"
		":return: The contents of the descriptors specified.\n"
		":rtype: List[SamplerDescriptor]\n"
		"\n"
		"" },
  { "GetDescriptorAccess", (PyCFunction) _wrap_ReplayController_GetDescriptorAccess, METH_NOARGS, (char *) "\n"
		"GetDescriptorAccess()\n"
		"\n"
		"Retrieve the descriptor accesses that happened at the current event.\n"
		"\n"
		":return: The descriptor accesses.\n"
		":rtype: List[DescriptorAccess]\n"
		"\n"
		"" },
  { "GetDescriptorLocations", (PyCFunction) _wrap_ReplayController_GetDescriptorLocations, METH_VARARGS, (char *) "\n"
		"GetDescriptorLocations(descriptorStore, ranges)\n"
		"\n"
		"Retrieve the logical locations for descriptors in a given descriptor store.\n"
		"\n"
		":param ResourceId descriptorStore: The descriptor store to be queried from.\n"
		":param List[DescriptorRange] ranges: The descriptor ranges to query.\n"
		":return: The descriptor logical locations.\n"
		":rtype: List[DescriptorLogicalLocation]\n"
		"\n"
		"" },
  { "GetDisassemblyTargets", (PyCFunction) _wrap_ReplayController_GetDisassemblyTargets, METH_O, (char *) "\n"
		"GetDisassemblyTargets(withPipeline)\n"
		"\n"
		"Retrieve the list of possible disassembly targets for :meth:`DisassembleShader`. The\n"
		"values are implementation dependent but will always include a default target first which is the\n"
		"native disassembly of the shader. Further options may be available for additional diassembly views\n"
		"or hardware-specific ISA formats.\n"
		"\n"
		":param bool withPipeline: More disassembly may be available when a pipeline is specified.\n"
		":return: The list of disassembly targets available.\n"
		":rtype: List[str]\n"
		"\n"
		"" },
  { "DisassembleShader", (PyCFunction) _wrap_ReplayController_DisassembleShader, METH_VARARGS, (char *) "\n"
		"DisassembleShader(pipeline, refl, target)\n"
		"\n"
		"Retrieve the disassembly for a given shader, for the given disassembly target.\n"
		"\n"
		":param ResourceId pipeline: The pipeline state object, if applicable, that this shader is bound to.\n"
		":param ShaderReflection refl: The shader reflection details of the shader to disassemble\n"
		":param str target: The name of the disassembly target to generate for. Must be one of the values\n"
		"  returned by :meth:`GetDisassemblyTargets`, or empty to use the default generation.\n"
		":return: The disassembly text, or an error message if something went wrong.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "SetCustomShaderIncludes", (PyCFunction) _wrap_ReplayController_SetCustomShaderIncludes, METH_O, (char *) "\n"
		"SetCustomShaderIncludes(directories)\n"
		"\n"
		"Sets a list of directories to search for include files when compiling custom shaders\n"
		"with the internal shader compiler.\n"
		"\n"
		".. note::\n"
		"  This is currently only supported for D3D11 and D3D12. For Vulkan includes can be supported via\n"
		"  configuring an external compiler to SPIR-V which is ingested.\n"
		"\n"
		":param List[str] directories: The absolute paths of the directories.\n"
		"\n"
		"" },
  { "BuildCustomShader", (PyCFunction) _wrap_ReplayController_BuildCustomShader, METH_VARARGS, (char *) "\n"
		"BuildCustomShader(entry, sourceEncoding, source, compileFlags, type)\n"
		"\n"
		"Builds a shader suitable for running on the local replay instance as a custom shader.\n"
		"\n"
		"System-level include directories can be set up via SetCustomShaderIncludes.\n"
		"\n"
		"See :data:`TextureDisplay.customShaderId`.\n"
		"\n"
		":param str entry: The entry point to use when compiling.\n"
		":param ShaderEncoding sourceEncoding: The encoding of the source data.\n"
		":param bytes source: The source data itself.\n"
		":param ShaderCompileFlags compileFlags: API-specific compilation flags.\n"
		":param ShaderStage type: The stage that this shader will be executed at.\n"
		":return: A ``tuple`` with the id of the new shader if compilation was successful,\n"
		"  :meth:`ResourceId.Null` otherwise, and a ``str`` with any warnings/errors from compilation.\n"
		":rtype: Tuple[ResourceId,str]\n"
		"\n"
		"" },
  { "FreeCustomShader", (PyCFunction) _wrap_ReplayController_FreeCustomShader, METH_O, (char *) "\n"
		"FreeCustomShader(id)\n"
		"\n"
		"Free a previously created custom shader.\n"
		"\n"
		"See :meth:`BuildCustomShader`.\n"
		"\n"
		":param ResourceId id: The id of the custom shader to free.\n"
		"\n"
		"" },
  { "BuildTargetShader", (PyCFunction) _wrap_ReplayController_BuildTargetShader, METH_VARARGS, (char *) "\n"
		"BuildTargetShader(entry, sourceEncoding, source, compileFlags, type)\n"
		"\n"
		"Builds a shader suitable for running in the capture's API as a replacement shader.\n"
		"\n"
		":param str entry: The entry point to use when compiling.\n"
		":param ShaderEncoding sourceEncoding: The encoding of the source data.\n"
		":param bytes source: The source data itself.\n"
		":param ShaderCompileFlags compileFlags: API-specific compilation flags.\n"
		":param ShaderStage type: The stage that this shader will be executed at.\n"
		":return: A ``tuple`` with the id of the new shader if compilation was successful,\n"
		"  :meth:`ResourceId.Null` otherwise, and a ``str`` with any warnings/errors from compilation.\n"
		":rtype: Tuple[ResourceId,str]\n"
		"\n"
		"" },
  { "GetTargetShaderEncodings", (PyCFunction) _wrap_ReplayController_GetTargetShaderEncodings, METH_NOARGS, (char *) "\n"
		"GetTargetShaderEncodings()\n"
		"\n"
		"Retrieve the list of supported :class:`ShaderEncoding` which can be build using\n"
		":meth:`BuildTargetShader`.\n"
		"\n"
		"The list is sorted in priority order, so if the caller has a shader in a form but could\n"
		"compile/translate it to another, prefer to satisfy the first encoding before later encodings.\n"
		"\n"
		"This typically means the 'native' encoding is listed first, and then subsequent encodings are\n"
		"compiled internally - so compiling externally could be preferable as it allows better customisation\n"
		"of the compile process or using alternate/updated tools.\n"
		"\n"
		":return: The list of target shader encodings available.\n"
		":rtype: List[ShaderEncoding]\n"
		"\n"
		"" },
  { "GetCustomShaderEncodings", (PyCFunction) _wrap_ReplayController_GetCustomShaderEncodings, METH_NOARGS, (char *) "\n"
		"GetCustomShaderEncodings()\n"
		"\n"
		"Retrieve the list of supported :class:`ShaderEncoding` which can be build using\n"
		":meth:`BuildCustomShader`.\n"
		"\n"
		"The list is sorted in priority order, so if the caller has a shader in a form but could\n"
		"compile/translate it to another, prefer to satisfy the first encoding before later encodings.\n"
		"\n"
		"This typically means the 'native' encoding is listed first, and then subsequent encodings are\n"
		"compiled internally - so compiling externally could be preferable as it allows better customisation\n"
		"of the compile process or using alternate/updated tools.\n"
		"\n"
		":return: The list of target shader encodings available.\n"
		":rtype: List[ShaderEncoding]\n"
		"\n"
		"" },
  { "GetCustomShaderSourcePrefixes", (PyCFunction) _wrap_ReplayController_GetCustomShaderSourcePrefixes, METH_NOARGS, (char *) "\n"
		"GetCustomShaderSourcePrefixes()\n"
		"\n"
		"Retrieve a list of source prefixes that should be applied to custom shaders of each\n"
		":class:`ShaderEncoding` before custom compilation prior to calling :meth:`BuildCustomShader`.\n"
		"\n"
		"This list provides source code prefixes which should be applied to a given custom shader in a\n"
		":class:`ShaderEncoding` *if and only if* that shader is being compiled in a custom step to a\n"
		"different encoding, prior to being passed to :meth:`BuildCustomShader`. This allows source\n"
		"compatibility even when doing custom compilation.\n"
		"\n"
		"For example a shader written in :data:`ShaderEncoding.HLSL` may be custom compiled to\n"
		":data:`ShaderEncoding.SPIRV` before being passed to :meth:`BuildCustomShader`. In this case any\n"
		"prefix for :data:`ShaderEncoding.HLSL` should be prepended to the source before custom compilation,\n"
		"to allow for defines and other helpers to be made available, since otherwise the shader may not\n"
		"compile.\n"
		"\n"
		"If a shader encoding is not in the list, no prefix is required. This may be possible even for a\n"
		"high level language such as :data:`ShaderEncoding.GLSL`.\n"
		"\n"
		":return: A list of pairs, listing a prefix for each shader encoding referenced.\n"
		":rtype: List[ShaderSourcePrefix]\n"
		"\n"
		"" },
  { "ReplaceResource", (PyCFunction) _wrap_ReplayController_ReplaceResource, METH_VARARGS, (char *) "\n"
		"ReplaceResource(original, replacement)\n"
		"\n"
		"Replace one resource with another for subsequent replay and analysis work.\n"
		"\n"
		"This is commonly used for modifying the capture by selectively replacing resources with newly\n"
		"created resources.\n"
		"\n"
		"See :meth:`BuildTargetShader`, :meth:`RemoveReplacement`.\n"
		"\n"
		":param ResourceId original: The id of the resource that should be substituted.\n"
		":param ResourceId replacement: The id of the new resource that should be used instead.\n"
		"\n"
		"" },
  { "ClearReplayCache", (PyCFunction) _wrap_ReplayController_ClearReplayCache, METH_NOARGS, (char *) "\n"
		"ClearReplayCache()\n"
		"\n"
		"Clear any cached data from previous replays and ensure subsequent replays fully\n"
		"re-initialise any data, including e.g. bindless feedback, printf results or mesh output data.\n"
		"\n"
		"" },
  { "ReloadShaderDebugInformation", (PyCFunction) _wrap_ReplayController_ReloadShaderDebugInformation, METH_NOARGS, (char *) "\n"
		"ReloadShaderDebugInformation()\n"
		"\n"
		"Reload the shader debug information for all shaders in the capture.\n"
		"\n"
		"" },
  { "RemoveReplacement", (PyCFunction) _wrap_ReplayController_RemoveReplacement, METH_O, (char *) "\n"
		"RemoveReplacement(id)\n"
		"\n"
		"Remove any previously specified replacement for an object.\n"
		"\n"
		"See :meth:`ReplaceResource`.\n"
		"\n"
		":param ResourceId id: The id of the resource that was previously being substituted.\n"
		"\n"
		"" },
  { "FreeTargetResource", (PyCFunction) _wrap_ReplayController_FreeTargetResource, METH_O, (char *) "\n"
		"FreeTargetResource(id)\n"
		"\n"
		"Free a previously created target shader.\n"
		"\n"
		"See :meth:`BuildTargetShader`.\n"
		"\n"
		":param ResourceId id: The id of the target shader to free.\n"
		"\n"
		"" },
  { "GetFrameInfo", (PyCFunction) _wrap_ReplayController_GetFrameInfo, METH_NOARGS, (char *) "\n"
		"GetFrameInfo()\n"
		"\n"
		"Retrieve the information about the frame contained in the capture.\n"
		"\n"
		":return: The frame information.\n"
		":rtype: FrameDescription\n"
		"\n"
		"" },
  { "GetStructuredFile", (PyCFunction) _wrap_ReplayController_GetStructuredFile, METH_NOARGS, (char *) "\n"
		"GetStructuredFile()\n"
		"\n"
		"Fetch the structured data representation of the capture loaded.\n"
		"\n"
		":return: The structured file.\n"
		":rtype: SDFile\n"
		"\n"
		"" },
  { "AddFakeMarkers", (PyCFunction) _wrap_ReplayController_AddFakeMarkers, METH_NOARGS, (char *) "\n"
		"AddFakeMarkers()\n"
		"\n"
		"Add fake marker regions to the list of actions in the capture, based on which\n"
		"textures are bound as outputs. Will not do anything if the capture already contains user marker\n"
		"regions.\n"
		"\n"
		".. warning::\n"
		"  This must be called *immediately* after capture load, calling it at a later time will cause\n"
		"  corruption. No other functions should be called between load and this one.\n"
		"\n"
		".. note::\n"
		"  The event IDs for fake marker pushes and pops will not be contiguous with the surrounding actions\n"
		"  and will be set to values above the last real event in the capture. This also means they break the\n"
		"  typical rules that event IDs always increase. It's recommended that these events are not\n"
		"  referenced directly in other calls such as SetFrameEvent, and fake markers should be used \n"
		"  sparingly at all compared to proper application-provided markers.\n"
		"\n"
		"" },
  { "GetRootActions", (PyCFunction) _wrap_ReplayController_GetRootActions, METH_NOARGS, (char *) "\n"
		"GetRootActions()\n"
		"\n"
		"Retrieve the list of root-level actions in the capture.\n"
		"\n"
		":return: The list of root-level actions in the capture.\n"
		":rtype: List[ActionDescription]\n"
		"\n"
		"" },
  { "FetchCounters", (PyCFunction) _wrap_ReplayController_FetchCounters, METH_O, (char *) "\n"
		"FetchCounters(counters)\n"
		"\n"
		"Retrieve the values of a specified set of counters.\n"
		"\n"
		":param List[GPUCounter] counters: The list of counters to fetch results for.\n"
		":return: The list of counter results generated.\n"
		":rtype: List[CounterResult]\n"
		"\n"
		"" },
  { "EnumerateCounters", (PyCFunction) _wrap_ReplayController_EnumerateCounters, METH_NOARGS, (char *) "\n"
		"EnumerateCounters()\n"
		"\n"
		"Retrieve a list of which counters are available in the current capture analysis\n"
		"implementation.\n"
		"\n"
		":return: The list of counters available.\n"
		":rtype: List[GPUCounter]\n"
		"\n"
		"" },
  { "DescribeCounter", (PyCFunction) _wrap_ReplayController_DescribeCounter, METH_O, (char *) "\n"
		"DescribeCounter(counter)\n"
		"\n"
		"Get information about what a counter actually represents, in terms of a human-readable\n"
		"understanding as well as the type and unit of the resulting information.\n"
		"\n"
		":param GPUCounter counter: The counter to query about.\n"
		":return: The description of the counter.\n"
		":rtype: CounterDescription\n"
		"\n"
		"" },
  { "GetResources", (PyCFunction) _wrap_ReplayController_GetResources, METH_NOARGS, (char *) "\n"
		"GetResources()\n"
		"\n"
		"Retrieve the list of all resources in the capture.\n"
		"\n"
		"This includes any object allocated a :class:`ResourceId`, that don't have any other state or\n"
		"are only used as intermediary elements.\n"
		"\n"
		":return: The list of resources in the capture.\n"
		":rtype: List[ResourceDescription]\n"
		"\n"
		"" },
  { "GetTextures", (PyCFunction) _wrap_ReplayController_GetTextures, METH_NOARGS, (char *) "\n"
		"GetTextures()\n"
		"\n"
		"Retrieve the list of textures alive in the capture.\n"
		"\n"
		":return: The list of textures in the capture.\n"
		":rtype: List[TextureDescription]\n"
		"\n"
		"" },
  { "GetBuffers", (PyCFunction) _wrap_ReplayController_GetBuffers, METH_NOARGS, (char *) "\n"
		"GetBuffers()\n"
		"\n"
		"Retrieve the list of buffers alive in the capture.\n"
		"\n"
		":return: The list of buffers in the capture.\n"
		":rtype: List[BufferDescription]\n"
		"\n"
		"" },
  { "GetDescriptorStores", (PyCFunction) _wrap_ReplayController_GetDescriptorStores, METH_NOARGS, (char *) "\n"
		"GetDescriptorStores()\n"
		"\n"
		"Retrieve the list of descriptor storage objects alive in the capture.\n"
		"\n"
		":return: The list of descriptor storage objects in the capture.\n"
		":rtype: List[DescriptorStoreDescription]\n"
		"\n"
		"" },
  { "GetDebugMessages", (PyCFunction) _wrap_ReplayController_GetDebugMessages, METH_NOARGS, (char *) "\n"
		"GetDebugMessages()\n"
		"\n"
		"Retrieve a list of any newly generated diagnostic messages.\n"
		"\n"
		"Every time this function is called, any debug messages returned will not be returned again. Only\n"
		"newly generated messages will be returned after that.\n"
		"\n"
		":return: The list of the :class:`DebugMessage` messages.\n"
		":rtype: List[DebugMessage]\n"
		"\n"
		"" },
  { "GetFatalErrorStatus", (PyCFunction) _wrap_ReplayController_GetFatalErrorStatus, METH_NOARGS, (char *) "\n"
		"GetFatalErrorStatus()\n"
		"\n"
		"Poll for the current status of the replay.\n"
		"\n"
		"This function can be used to monitor to see if a fatal error has been encountered and react\n"
		"appropriately, such as by displaying a message to the user. The replay controller interface should\n"
		"remain stable and return null/empty data for the most part, but it's recommended for maximum\n"
		"stability to stop using the controller when a fatal error is encountered.\n"
		"\n"
		"If there has been no error, this will return :data:`ResultCode.Succeeded`. If there has been an\n"
		"error this will return the error code every time, it will not be 'consumed' so it's safe to have\n"
		"multiple things checking it.\n"
		"\n"
		":return: The current fatal error status.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { "GetShaderEntryPoints", (PyCFunction) _wrap_ReplayController_GetShaderEntryPoints, METH_O, (char *) "\n"
		"GetShaderEntryPoints(shader)\n"
		"\n"
		"Retrieve a list of entry points for a shader.\n"
		"\n"
		"If the given ID doesn't specify a shader, an empty list will be return. On some APIs, the list will\n"
		"only ever have one result (only one entry point per shader).\n"
		"\n"
		":param ResourceId shader: The shader to look up entry points for.\n"
		":return: The list of the :class:`ShaderEntryPoint` messages.\n"
		":rtype: List[ShaderEntryPoint]\n"
		"\n"
		"" },
  { "GetShader", (PyCFunction) _wrap_ReplayController_GetShader, METH_VARARGS, (char *) "\n"
		"GetShader(pipeline, shader, entry)\n"
		"\n"
		"Retrieve the information about the frame contained in the capture.\n"
		"\n"
		":param ResourceId pipeline: The pipeline state object, if applicable, that this shader is bound to.\n"
		":param ResourceId shader: The shader to get reflection data for.\n"
		":param ShaderEntryPoint entry: The entry point within the shader to reflect. May be ignored on some\n"
		"  APIs\n"
		":return: The frame information.\n"
		":rtype: ShaderReflection\n"
		"\n"
		"" },
  { "PickPixel", (PyCFunction) _wrap_ReplayController_PickPixel, METH_VARARGS, (char *) "\n"
		"PickPixel(textureId, x, y, sub, typeCast)\n"
		"\n"
		"Retrieve the contents of a particular pixel in a texture.\n"
		"\n"
		".. note::\n"
		"  X and Y co-ordinates are always considered to be top-left, even on GL, for consistency between\n"
		"  APIs and preventing the need for API-specific code in most cases. This means if co-ordinates are\n"
		"  fetched from e.g. viewport or scissor data or other GL pipeline state which is perhaps in\n"
		"  bottom-left co-ordinates, care must be taken to translate them.\n"
		"\n"
		":param ResourceId textureId: The texture to pick the pixel from.\n"
		":param int x: The x co-ordinate to pick from.\n"
		":param int y: The y co-ordinate to pick from.\n"
		":param Subresource sub: The subresource within this texture to use.\n"
		":param CompType typeCast: If possible interpret the texture with this type instead of its normal\n"
		"  type. If set to :data:`CompType.Typeless` then no cast is applied, otherwise where allowed the\n"
		"  texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned\n"
		"  normalised values.\n"
		":return: The contents of the pixel.\n"
		":rtype: PixelValue\n"
		"\n"
		"" },
  { "GetMinMax", (PyCFunction) _wrap_ReplayController_GetMinMax, METH_VARARGS, (char *) "\n"
		"GetMinMax(textureId, sub, typeCast)\n"
		"\n"
		"Retrieves the minimum and maximum values in the specified texture.\n"
		"\n"
		":param ResourceId textureId: The texture to get the values from.\n"
		":param Subresource sub: The subresource within this texture to use.\n"
		":param CompType typeCast: If possible interpret the texture with this type instead of its normal\n"
		"  type. If set to :data:`CompType.Typeless` then no cast is applied, otherwise where allowed the\n"
		"  texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned\n"
		"  normalised values.\n"
		":return: A tuple with the minimum and maximum pixel values respectively.\n"
		":rtype: Tuple[PixelValue,PixelValue]\n"
		"\n"
		"" },
  { "GetHistogram", (PyCFunction) _wrap_ReplayController_GetHistogram, METH_VARARGS, (char *) "\n"
		"GetHistogram(textureId, sub, typeCast, minval, maxval, channels)\n"
		"\n"
		"Retrieve a list of values that can be used to show a histogram of values for the\n"
		"specified texture.\n"
		"\n"
		"The output list contains N buckets, and each bucket has the number of pixels that falls in each\n"
		"bucket when the pixel values are divided between ``minval`` and ``maxval``.\n"
		"\n"
		":param ResourceId textureId: The texture to get the histogram from.\n"
		":param Subresource sub: The subresource within this texture to use.\n"
		":param CompType typeCast: If possible interpret the texture with this type instead of its normal\n"
		"  type. If set to :data:`CompType.Typeless` then no cast is applied, otherwise where allowed the\n"
		"  texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned\n"
		"  normalised values.\n"
		":param float minval: The lower end of the smallest bucket. If any values are below this, they are\n"
		"  not added to any bucket.\n"
		":param float maxval: The upper end of the largest bucket. If any values are above this, they are\n"
		"  not added to any bucket.\n"
		":param Tuple[bool,bool,bool,bool] channels: A set of four flags indicating whether each of RGBA\n"
		"  respectively should be included in the count.\n"
		":return: A list of the unnormalised bucket values.\n"
		":rtype: List[int]\n"
		"\n"
		"" },
  { "PixelHistory", (PyCFunction) _wrap_ReplayController_PixelHistory, METH_VARARGS, (char *) "\n"
		"PixelHistory(texture, x, y, sub, typeCast)\n"
		"\n"
		"Retrieve the history of modifications to the selected pixel on the selected texture.\n"
		"\n"
		".. note::\n"
		"  X and Y co-ordinates are always considered to be top-left, even on GL, for consistency between\n"
		"  APIs and preventing the need for API-specific code in most cases. This means if co-ordinates are\n"
		"  fetched from e.g. viewport or scissor data or other GL pipeline state which is perhaps in\n"
		"  bottom-left co-ordinates, care must be taken to translate them.\n"
		"\n"
		":param ResourceId texture: The texture to search for modifications.\n"
		":param int x: The x co-ordinate.\n"
		":param int y: The y co-ordinate.\n"
		":param Subresource sub: The subresource within this texture to use.\n"
		":param CompType typeCast: If possible interpret the texture with this type instead of its normal\n"
		"  type. If set to :data:`CompType.Typeless` then no cast is applied, otherwise where allowed the\n"
		"  texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned\n"
		"  normalised values.\n"
		":return: The list of pixel history events.\n"
		":rtype: List[PixelModification]\n"
		"\n"
		"" },
  { "DebugVertex", (PyCFunction) _wrap_ReplayController_DebugVertex, METH_VARARGS, (char *) "\n"
		"DebugVertex(vertid, instid, idx, view)\n"
		"\n"
		"Retrieve a debugging trace from running a vertex shader.\n"
		"\n"
		":param int vertid: The vertex ID as a 0-based index up to the number of vertices in the draw.\n"
		":param int instid: The instance ID as a 0-based index up to the number of instances in the draw.\n"
		":param int idx: The actual index used to look up vertex inputs, either from the vertex ID for non-\n"
		"  indexed draws or drawn from the index buffer. This must have all drawcall offsets applied.\n"
		":param int view: The index of the multiview viewport to use, or 0 if multiview is not in use.\n"
		":return: The resulting trace resulting from debugging. Destroy with\n"
		"  :meth:`FreeTrace`.\n"
		":rtype: ShaderDebugTrace\n"
		"\n"
		"" },
  { "DebugPixel", (PyCFunction) _wrap_ReplayController_DebugPixel, METH_VARARGS, (char *) "\n"
		"DebugPixel(x, y, inputs)\n"
		"\n"
		"Retrieve a debugging trace from running a pixel shader.\n"
		"\n"
		".. note::\n"
		"  X and Y co-ordinates are always considered to be top-left, even on GL, for consistency between\n"
		"  APIs and preventing the need for API-specific code in most cases. This means if co-ordinates are\n"
		"  fetched from e.g. viewport or scissor data or other GL pipeline state which is perhaps in\n"
		"  bottom-left co-ordinates, care must be taken to translate them.\n"
		"\n"
		":param int x: The x co-ordinate.\n"
		":param int y: The y co-ordinate.\n"
		":param DebugPixelInputs inputs: Specific properties to select which fragment to debug e.g.\n"
		"  sample: The multi-sampled sample. Ignored if non-multisampled texture.\n"
		"  primitive: Debug the pixel from this primitive if there's ambiguity. If set to\n"
		"  :data:`NoPreference` then a random fragment writing to the given co-ordinate is debugged.\n"
		"  view: Debug the fragment writing to this view for layered or multiview rendering, \n"
		"  ignored if set to :data:`NoPreference`.\n"
		":return: The resulting trace resulting from debugging. Destroy with :meth:`FreeTrace`.\n"
		":rtype: ShaderDebugTrace\n"
		"\n"
		"" },
  { "DebugThread", (PyCFunction) _wrap_ReplayController_DebugThread, METH_VARARGS, (char *) "\n"
		"DebugThread(groupid, threadid)\n"
		"\n"
		"Retrieve a debugging trace from running a compute thread.\n"
		"\n"
		":param Tuple[int,int,int] groupid: A list containing the 3D workgroup index.\n"
		":param Tuple[int,int,int] threadid: A list containing the 3D thread index within the workgroup.\n"
		":return: The resulting trace resulting from debugging. Destroy with\n"
		"  :meth:`FreeTrace`.\n"
		":rtype: ShaderDebugTrace\n"
		"\n"
		"" },
  { "DebugMeshThread", (PyCFunction) _wrap_ReplayController_DebugMeshThread, METH_VARARGS, (char *) "\n"
		"DebugMeshThread(groupid, threadid)\n"
		"\n"
		"Retrieve a debugging trace from running a mesh shader.\n"
		"\n"
		":param Tuple[int,int,int] groupid: A list containing the 3D workgroup index.\n"
		":param Tuple[int,int,int] threadid: A list containing the 3D thread index within the workgroup.\n"
		":return: The resulting trace resulting from debugging. Destroy with\n"
		"  :meth:`FreeTrace`.\n"
		":rtype: ShaderDebugTrace\n"
		"\n"
		"" },
  { "ContinueDebug", (PyCFunction) _wrap_ReplayController_ContinueDebug, METH_O, (char *) "\n"
		"ContinueDebug(debugger)\n"
		"\n"
		"Continue a shader's debugging with a given shader debugger instance. This will run an\n"
		"implementation defined number of steps and then return those steps in a list. This may be a fixed\n"
		"number of steps or it may run for a fixed length of time and return as many steps as can be\n"
		"calculated in that time.\n"
		"\n"
		"This will always perform at least one step. If the list is empty, the debugging process has\n"
		"completed, further calls will return an empty list.\n"
		"\n"
		":param ShaderDebugger debugger: The shader debugger to continue running.\n"
		":return: A number of subsequent states.\n"
		":rtype: List[ShaderDebugState]\n"
		"\n"
		"" },
  { "FreeTrace", (PyCFunction) _wrap_ReplayController_FreeTrace, METH_O, (char *) "\n"
		"FreeTrace(trace)\n"
		"\n"
		"Free a debugging trace from running a shader invocation debug.\n"
		"\n"
		":param ShaderDebugTrace trace: The shader debugging trace to free.\n"
		"\n"
		"" },
  { "GetUsage", (PyCFunction) _wrap_ReplayController_GetUsage, METH_O, (char *) "\n"
		"GetUsage(id)\n"
		"\n"
		"Retrieve a list of ways a given resource is used.\n"
		"\n"
		":param ResourceId id: The id of the texture or buffer resource to be queried.\n"
		":return: The list of usages of the resource.\n"
		":rtype: List[EventUsage]\n"
		"\n"
		"" },
  { "GetCBufferVariableContents", (PyCFunction) _wrap_ReplayController_GetCBufferVariableContents, METH_VARARGS, (char *) "\n"
		"GetCBufferVariableContents(pipeline, shader, stage, entryPoint, cbufslot, buffer, offset, length)\n"
		"\n"
		"Retrieve the contents of a constant block by reading from memory or their source\n"
		"otherwise.\n"
		"\n"
		":param ResourceId pipeline: The pipeline state object, if applicable, that this shader is bound to.\n"
		":param ResourceId shader: The id of the shader to use for metadata.\n"
		":param ShaderStage stage: The shader stage to fetch variables from.\n"
		":param str entryPoint: The entry point of the shader being used. In some APIs, this is ignored.\n"
		":param int cbufslot: The index in the :data:`ShaderReflection.constantBlocks` list to look up.\n"
		":param ResourceId buffer: The id of the buffer to use for data. If\n"
		"  :data:`ConstantBlock.bufferBacked` is ``False`` this is ignored.\n"
		":param int offset: Retrieve buffer contents starting at this byte offset.\n"
		":param int length: Retrieve this many bytes after :paramref:`offset`. May be 0 to fetch the rest of the\n"
		"  buffer.\n"
		":return: The shader variables with their contents.\n"
		":rtype: List[ShaderVariable]\n"
		"\n"
		"" },
  { "SaveTexture", (PyCFunction) _wrap_ReplayController_SaveTexture, METH_VARARGS, (char *) "\n"
		"SaveTexture(saveData, path)\n"
		"\n"
		"Save a texture to a file on disk, with possible transformation to map a complex\n"
		"texture to something compatible with the target file format.\n"
		"\n"
		":param TextureSave saveData: The configuration settings of which texture to save, and how\n"
		":param str path: The path to save to on disk.\n"
		":return: The result of the operation.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { "GetPostVSData", (PyCFunction) _wrap_ReplayController_GetPostVSData, METH_VARARGS, (char *) "\n"
		"GetPostVSData(instance, view, stage)\n"
		"\n"
		"Retrieve the generated data from one of the geometry processing shader stages.\n"
		"\n"
		":param int instance: The index of the instance to retrieve data for, or 0 for non-instanced draws.\n"
		":param int view: The index of the multiview view to retrieve data for, or 0 if multiview is disabled.\n"
		":param MeshDataStage stage: The stage of the geometry processing pipeline to retrieve data from.\n"
		":return: The information describing where the post-transform data is stored.\n"
		":rtype: MeshFormat\n"
		"\n"
		"" },
  { "GetBufferData", (PyCFunction) _wrap_ReplayController_GetBufferData, METH_VARARGS, (char *) "\n"
		"GetBufferData(buff, offset, len)\n"
		"\n"
		"Retrieve the contents of a range of a buffer as a ``bytes``.\n"
		"\n"
		":param ResourceId buff: The id of the buffer to retrieve data from.\n"
		":param int offset: The byte offset to the start of the range.\n"
		":param int len: The length of the range, or 0 to retrieve the rest of the bytes in the buffer.\n"
		":return: The requested buffer contents.\n"
		":rtype: bytes\n"
		"\n"
		"" },
  { "GetTextureData", (PyCFunction) _wrap_ReplayController_GetTextureData, METH_VARARGS, (char *) "\n"
		"GetTextureData(tex, sub)\n"
		"\n"
		"Retrieve the contents of one subresource of a texture as a ``bytes``.\n"
		"\n"
		".. note:: For 3D textures a whole width x height x depth mip is returned, you can't select a single\n"
		"  depth slice using :data:`Subresource.slice`.\n"
		"\n"
		":param ResourceId tex: The id of the texture to retrieve data from.\n"
		":param Subresource sub: The subresource within this texture to use.\n"
		":return: The requested texture contents.\n"
		":rtype: bytes\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__IReplayController_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ReplayController",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__IReplayController_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__IReplayController_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__IReplayController_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__IReplayController_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The primary interface to access the information in a capture and the current state, as\n"
		"well as control the replay and analysis functionality available.\n"
		"\n"
		".. function:: KillCallback()\n"
		"\n"
		"  Not an actual member function - the signature for any ``KillCallback`` callbacks.\n"
		"\n"
		"  Called whenever some on-going blocking process needs to determine if it should close.\n"
		"\n"
		"  :return: Whether or not the process should be killed.\n"
		"  :rtype: bool\n"
		"\n"
		".. function:: ProgressCallback()\n"
		"\n"
		"  Not an actual member function - the signature for any ``ProgressCallback`` callbacks.\n"
		"\n"
		"  Called by an on-going blocking process to update a progress bar or similar user feedback.\n"
		"\n"
		"  The progress value will go from 0.0 to 1.0 as the process completes. Any other value will indicate\n"
		"  that the process has completed\n"
		"\n"
		"  :param float progress: The latest progress amount.\n"
		"\n"
		".. function:: PreviewWindowCallback()\n"
		"\n"
		"  Not an actual member function - the signature for any ``PreviewWindowCallback`` callbacks.\n"
		"\n"
		"  Called when a preview window could optionally be opened to display some information. It will be\n"
		"  called repeatedly with :paramref:`active` set to ``True`` to allow any platform-specific message\n"
		"  pumping.\n"
		"\n"
		"  :param bool active: ``True`` if a preview window is active/opened, ``False`` if it has closed.\n"
		"  :return: The windowing data for a preview window, or empty/default values if no window should be\n"
		"    created.\n"
		"  :rtype: WindowingData\n"
		"\n"
		".. data:: NoPreference\n"
		"\n"
		"  No preference for a particular value, see :meth:`ReplayController.DebugPixel`.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__IReplayController_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__IReplayController_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__IReplayController_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__IReplayController_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__IReplayController_type};

static SwigPyGetSet TargetControl___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ITargetControl_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ITargetControl.__dict__", (void *) &TargetControl___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ITargetControl_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ITargetControl_methods[] = {
  { "Shutdown", (PyCFunction) _wrap_TargetControl_Shutdown, METH_NOARGS, (char *) "\n"
		"Shutdown()\n"
		"\n"
		"Closes the connection without affecting the running application.\n"
		"" },
  { "Connected", (PyCFunction) _wrap_TargetControl_Connected, METH_NOARGS, (char *) "\n"
		"Connected()\n"
		"\n"
		"Determines if the connection is still alive.\n"
		"\n"
		":return: ``True`` if the connection still appears to be working, ``False`` if it has been closed.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "GetTarget", (PyCFunction) _wrap_TargetControl_GetTarget, METH_NOARGS, (char *) "\n"
		"GetTarget()\n"
		"\n"
		"Retrieves the target's name or identifier - typically the name of the executable.\n"
		"\n"
		":return: The target name.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "GetAPI", (PyCFunction) _wrap_TargetControl_GetAPI, METH_NOARGS, (char *) "\n"
		"GetAPI()\n"
		"\n"
		"Retrieves the API currently in use by the target.\n"
		"\n"
		":return: The API name, or empty if no API is initialised yet.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "GetPID", (PyCFunction) _wrap_TargetControl_GetPID, METH_NOARGS, (char *) "\n"
		"GetPID()\n"
		"\n"
		"Retrieves the Process ID (PID) of the target on its local system.\n"
		"\n"
		":return: The Process ID, or 0 if that's not applicable on the target platform.\n"
		":rtype: int\n"
		"\n"
		"" },
  { "GetBusyClient", (PyCFunction) _wrap_TargetControl_GetBusyClient, METH_NOARGS, (char *) "\n"
		"GetBusyClient()\n"
		"\n"
		"If a busy message was received, determine the client keeping the target busy.\n"
		"\n"
		":return: The name of the client currently connected to the target.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "TriggerCapture", (PyCFunction) _wrap_TargetControl_TriggerCapture, METH_O, (char *) "\n"
		"TriggerCapture(numFrames)\n"
		"\n"
		"Trigger a capture on the target, with the same semantics as if the capture key had\n"
		"been pressed - from the next presentation call after this message is processed on the target to the\n"
		"next after that.\n"
		"\n"
		":param int numFrames: How many frames to capture. These will be captured sequentially and\n"
		"  independently to separate files.\n"
		"\n"
		"" },
  { "QueueCapture", (PyCFunction) _wrap_TargetControl_QueueCapture, METH_VARARGS, (char *) "\n"
		"QueueCapture(frameNumber, numFrames)\n"
		"\n"
		"Queue up a capture to happen on a particular frame number. When this frame is about to\n"
		"begin a capture is begun, and it ends when this frame number ends.\n"
		"\n"
		".. note:: Frame 0 is defined as starting when the device is created, up to the first swapchain\n"
		"  present defined frame boundary.\n"
		"\n"
		":param int frameNumber: The number of the frame to capture on.\n"
		":param int numFrames: How many frames to capture. These will be captured sequentially and\n"
		"  independently to separate files.\n"
		"\n"
		"" },
  { "CopyCapture", (PyCFunction) _wrap_TargetControl_CopyCapture, METH_VARARGS, (char *) "\n"
		"CopyCapture(captureId, localpath)\n"
		"\n"
		"Begin copying a given capture stored on a remote machine to the local machine over the\n"
		"target control connection.\n"
		"\n"
		":param int captureId: The identifier of the remote capture.\n"
		":param str localpath: The absolute path on the local system where the file should be saved.\n"
		"\n"
		"" },
  { "DeleteCapture", (PyCFunction) _wrap_TargetControl_DeleteCapture, METH_O, (char *) "\n"
		"DeleteCapture(captureId)\n"
		"\n"
		"Delete a capture from the remote machine.\n"
		"\n"
		":param int captureId: The identifier of the remote capture.\n"
		"\n"
		"" },
  { "ReceiveMessage", (PyCFunction) _wrap_TargetControl_ReceiveMessage, METH_O, (char *) "\n"
		"ReceiveMessage(progress)\n"
		"\n"
		"Query to see if a message has been received from the remote system.\n"
		"\n"
		"The details of the types of messages that can be received are listed under\n"
		":class:`TargetControlMessage`.\n"
		"\n"
		".. note:: If no message has been received, this function will pump the connection. You are expected\n"
		"  to continually call this function and process any messages to kee pthe connection alive.\n"
		"\n"
		"  This function will block but only to a limited degree. If no message is waiting after a small time\n"
		"  it will return with a No-op message to allow further processing.\n"
		"\n"
		":param ProgressCallback progress: A callback that will be repeatedly called with an updated progress\n"
		"  value when a long blocking message is coming through, e.g. a capture copy. Can be ``None`` if no\n"
		"  progress is desired.\n"
		"  Callback function signature must match :func:`ProgressCallback`.\n"
		":return: The message that was received.\n"
		":rtype: TargetControlMessage\n"
		"\n"
		"" },
  { "CycleActiveWindow", (PyCFunction) _wrap_TargetControl_CycleActiveWindow, METH_NOARGS, (char *) "\n"
		"CycleActiveWindow()\n"
		"\n"
		"Cycle the currently active window if there are more windows to capture.\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ITargetControl_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.TargetControl",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ITargetControl_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__ITargetControl_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__ITargetControl_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ITargetControl_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A connection to a running application with RenderDoc injected, which allows limited\n"
		"control over the capture process as well as querying the current status.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ITargetControl_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ITargetControl_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ITargetControl_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ITargetControl_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ITargetControl_type};

static SwigPyGetSet CaptureAccess___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ICaptureAccess_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ICaptureAccess.__dict__", (void *) &CaptureAccess___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ICaptureAccess_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ICaptureAccess_methods[] = {
  { "GetAvailableGPUs", (PyCFunction) _wrap_CaptureAccess_GetAvailableGPUs, METH_NOARGS, (char *) "\n"
		"GetAvailableGPUs()\n"
		"\n"
		"Returns the list of available GPUs, that can be used in combination with\n"
		":class:`ReplayOptions` to force replay on a particular GPU.\n"
		"\n"
		":return: The list of GPUs available.\n"
		":rtype: List[GPUDevice]\n"
		"\n"
		"" },
  { "GetSectionCount", (PyCFunction) _wrap_CaptureAccess_GetSectionCount, METH_NOARGS, (char *) "\n"
		"GetSectionCount()\n"
		"\n"
		"Retrieve the total number of available sections.\n"
		"\n"
		":return: The number of sections in the capture\n"
		":rtype: int\n"
		"\n"
		"" },
  { "FindSectionByName", (PyCFunction) _wrap_CaptureAccess_FindSectionByName, METH_O, (char *) "\n"
		"FindSectionByName(name)\n"
		"\n"
		"Locate the index of a section by its name. Returns ``-1`` if the section is not found.\n"
		"\n"
		"This index should not be cached, as writing sections could re-order the indices.\n"
		"\n"
		":param str name: The name of the section to search for.\n"
		":return: The index of the section, or ``-1`` if not found.\n"
		":rtype: int\n"
		"\n"
		"" },
  { "FindSectionByType", (PyCFunction) _wrap_CaptureAccess_FindSectionByType, METH_O, (char *) "\n"
		"FindSectionByType(type)\n"
		"\n"
		"Locate the index of a section by its type. Returns ``-1`` if the section is not found.\n"
		"\n"
		"This index should not be cached, as writing sections could re-order the indices.\n"
		"\n"
		":param SectionType type: The type of the section to search for.\n"
		":return: The index of the section, or ``-1`` if not found.\n"
		":rtype: int\n"
		"\n"
		"" },
  { "GetSectionProperties", (PyCFunction) _wrap_CaptureAccess_GetSectionProperties, METH_O, (char *) "\n"
		"GetSectionProperties(index)\n"
		"\n"
		"Get the describing properties of the specified section.\n"
		"\n"
		":param int index: The index of the section.\n"
		":return: The properties of the section, if the index is valid.\n"
		":rtype: SectionProperties\n"
		"\n"
		"" },
  { "GetSectionContents", (PyCFunction) _wrap_CaptureAccess_GetSectionContents, METH_O, (char *) "\n"
		"GetSectionContents(index)\n"
		"\n"
		"Get the raw byte contents of the specified section.\n"
		"\n"
		":param int index: The index of the section.\n"
		":return: The raw contents of the section, if the index is valid.\n"
		":rtype: bytes\n"
		"\n"
		"" },
  { "WriteSection", (PyCFunction) _wrap_CaptureAccess_WriteSection, METH_VARARGS, (char *) "\n"
		"WriteSection(props, contents)\n"
		"\n"
		"Writes a new section with specified properties and contents. If an existing section\n"
		"already has the same type or name, it will be overwritten (two sections cannot share the same type\n"
		"or name).\n"
		"\n"
		":param SectionProperties props: The properties of the section to be written.\n"
		":param bytes contents: The raw contents of the section.\n"
		":return: The result of the operation.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { "HasCallstacks", (PyCFunction) _wrap_CaptureAccess_HasCallstacks, METH_NOARGS, (char *) "\n"
		"HasCallstacks()\n"
		"\n"
		"Query if callstacks are available.\n"
		"\n"
		":return: ``True`` if any callstacks are available, ``False`` otherwise.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "InitResolver", (PyCFunction) _wrap_CaptureAccess_InitResolver, METH_VARARGS, (char *) "\n"
		"InitResolver(interactive, progress)\n"
		"\n"
		"Begin initialising a callstack resolver, looking up symbol files and caching as\n"
		"necessary.\n"
		"\n"
		"This function blocks while trying to initialise callstack resolving, so it should be called on a\n"
		"separate thread.\n"
		"\n"
		":param bool interactive: ``True`` if missing symbols or other prompts should be resolved interactively.\n"
		"  If this is ``False``, the function will not interact or block forever on user interaction and will\n"
		"  always assume the input is effectively 'cancel' or empty. This may cause the symbol resolution to\n"
		"  fail.\n"
		":param ProgressCallback progress: A callback that will be repeatedly called with an updated progress\n"
		"  value for the resolver process. Can be ``None`` if no progress is desired.\n"
		"  Callback function signature must match :func:`ProgressCallback`.\n"
		":return: The result of the operation.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { "GetResolve", (PyCFunction) _wrap_CaptureAccess_GetResolve, METH_O, (char *) "\n"
		"GetResolve(callstack)\n"
		"\n"
		"Retrieve the details of each stackframe in the provided callstack.\n"
		"\n"
		"Must only be called after :meth:`InitResolver` has returned ``True``.\n"
		"\n"
		":param List[int] callstack: The integer addresses in the original callstack.\n"
		":return: The list of resolved callstack entries as strings.\n"
		":rtype: List[str]\n"
		"\n"
		"" },
  { "DriverName", (PyCFunction) _wrap_CaptureAccess_DriverName, METH_NOARGS, (char *) "\n"
		"DriverName()\n"
		"\n"
		"Retrieves the name of the driver that was used to create this capture.\n"
		"\n"
		":return: A simple string identifying the driver used to make the capture.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "EmbedDependenciesIntoCapture", (PyCFunction) _wrap_CaptureAccess_EmbedDependenciesIntoCapture, METH_NOARGS, (char *) "\n"
		"EmbedDependenciesIntoCapture()\n"
		"\n"
		"Stores the dependent file data into the capture i.e. shader debug files.\n"
		"\n"
		"This reads the contents of the dependent files and stores their file contents into the capture.\n"
		"This can help the capture to be more portable by embedding all externally referenced dependent files.\n"
		"Use :meth:`RemoveDependenciesFromCapture` to remove the embedded file data.\n"
		"\n"
		".. warning::\n"
		"  Will remove all the existing embedded file data from the capture.\n"
		"  Will directly modify the capture file on disk.\n"
		"\n"
		".. note::\n"
		"  This will increase the size of the capture file.\n"
		"  Externally referenced files which can't be found on disk are skipped.\n"
		"\n"
		":return: The result of the operation.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { "RemoveDependenciesFromCapture", (PyCFunction) _wrap_CaptureAccess_RemoveDependenciesFromCapture, METH_NOARGS, (char *) "\n"
		"RemoveDependenciesFromCapture()\n"
		"\n"
		"Removes the dependent files storage from the capture i.e. shader debug files.\n"
		"\n"
		"The files will be still be considered to be referenced by the capture and could be re-embedded \n"
		"by calling :meth:`EmbedDependenciesIntoCapture`.\n"
		"\n"
		".. warning::\n"
		"  Will directly modify the capture file on disk.\n"
		"\n"
		":return: The result of the operation.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { "HasEmbeddedDependencies", (PyCFunction) _wrap_CaptureAccess_HasEmbeddedDependencies, METH_NOARGS, (char *) "\n"
		"HasEmbeddedDependencies()\n"
		"\n"
		"Are there any depdendent files embedded in the capture i.e. shader debug files.\n"
		"\n"
		":return: ``True`` if the capture has embedded dependent files, or ``False`` if the capture does not any embedded dependent files.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "HasPendingDependencies", (PyCFunction) _wrap_CaptureAccess_HasPendingDependencies, METH_NOARGS, (char *) "\n"
		"HasPendingDependencies()\n"
		"\n"
		"Does the capture have references to dependecies i.e. shader debug files.\n"
		"\n"
		":return: ``True`` if the capture has references to dependent files, or ``False`` if the capture does not contain references to dependent files.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "GetPendingDependenciesNicknames", (PyCFunction) _wrap_CaptureAccess_GetPendingDependenciesNicknames, METH_NOARGS, (char *) "\n"
		"GetPendingDependenciesNicknames()\n"
		"\n"
		"Retrieve a list of the nicknames of the externally referenced dependent files being referenced \n"
		"by the capture i.e. shader debug files.\n"
		"\n"
		".. note::\n"
		"  The nicknames can be arbitary and do not have to be a filename or a file path.\n"
		"\n"
		":return: A list of the nicknames used to reference dependencies.\n"
		":rtype: List[str]\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ICaptureAccess_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.CaptureAccess",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ICaptureAccess_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__ICaptureAccess_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__ICaptureAccess_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ICaptureAccess_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"An interface for accessing a capture, possibly over a network connection. This is a\n"
		"subset of the functionality provided in :class:`CaptureFile` which only supports import/export\n"
		"and construction of files.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ICaptureAccess_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ICaptureAccess_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ICaptureAccess_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ICaptureAccess_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ICaptureAccess_type};

static SwigPyGetSet RemoteServer___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__IRemoteServer_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"IRemoteServer.__dict__", (void *) &RemoteServer___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__IRemoteServer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__IRemoteServer_methods[] = {
  { "ShutdownConnection", (PyCFunction) _wrap_RemoteServer_ShutdownConnection, METH_NOARGS, (char *) "\n"
		"ShutdownConnection()\n"
		"\n"
		"Closes the connection without affecting the running server.\n"
		"" },
  { "ShutdownServerAndConnection", (PyCFunction) _wrap_RemoteServer_ShutdownServerAndConnection, METH_NOARGS, (char *) "\n"
		"ShutdownServerAndConnection()\n"
		"\n"
		"Closes the connection and also tells the running server to close.\n"
		"" },
  { "Ping", (PyCFunction) _wrap_RemoteServer_Ping, METH_NOARGS, (char *) "\n"
		"Ping()\n"
		"\n"
		"Pings the remote server to ensure the connection is still alive.\n"
		"\n"
		":return: The result of the operation - if a failure occurred the connection is no longer alive.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { "LocalProxies", (PyCFunction) _wrap_RemoteServer_LocalProxies, METH_NOARGS, (char *) "\n"
		"LocalProxies()\n"
		"\n"
		"Retrieve a list of renderers available for local proxying.\n"
		"\n"
		"These will be strings like \"D3D11\" or \"OpenGL\".\n"
		"\n"
		":return: A list of names of the local proxies.\n"
		":rtype: List[str]\n"
		"\n"
		"" },
  { "RemoteSupportedReplays", (PyCFunction) _wrap_RemoteServer_RemoteSupportedReplays, METH_NOARGS, (char *) "\n"
		"RemoteSupportedReplays()\n"
		"\n"
		"Retrieve a list of renderers supported by the remote server.\n"
		"\n"
		"These will be strings like \"D3D11\" or \"OpenGL\".\n"
		"\n"
		":return: A list of names of the remote renderers.\n"
		":rtype: List[str]\n"
		"\n"
		"" },
  { "GetHomeFolder", (PyCFunction) _wrap_RemoteServer_GetHomeFolder, METH_NOARGS, (char *) "\n"
		"GetHomeFolder()\n"
		"\n"
		"Retrieve the path on the remote system where browsing can begin.\n"
		"\n"
		":return: The 'home' path where browsing for files or folders can begin.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "ListFolder", (PyCFunction) _wrap_RemoteServer_ListFolder, METH_O, (char *) "\n"
		"ListFolder(path)\n"
		"\n"
		"Retrieve the contents of a folder path on the remote system.\n"
		"\n"
		"If an error occurs, a single :class:`PathEntry` will be returned with appropriate error flags.\n"
		"\n"
		":param str path: The remote path to list.\n"
		":return: The contents of the specified folder.\n"
		":rtype: List[PathEntry]\n"
		"\n"
		"" },
  { "ExecuteAndInject", (PyCFunction) _wrap_RemoteServer_ExecuteAndInject, METH_VARARGS, (char *) "\n"
		"ExecuteAndInject(app, workingDir, cmdLine, env, opts)\n"
		"\n"
		"Launch an application and inject into it to allow capturing.\n"
		"\n"
		"This happens on the remote system, so all paths are relative to the remote filesystem.\n"
		"\n"
		":param str app: The path to the application to run.\n"
		":param str workingDir: The working directory to use when running the application. If blank, the\n"
		"  directory containing the application is used.\n"
		":param str cmdLine: The command line to use when running the application, it will be processed in a\n"
		"  platform specific way to generate arguments.\n"
		":param List[EnvironmentModification] env: Any environment changes that should be made when running\n"
		"  the program.\n"
		":param CaptureOptions opts: The capture options to use when injecting into the program.\n"
		":return: The :class:`ExecuteResult` indicating both the status of the operation (success or failure)\n"
		"  and any reason for failure, or else the ident where the new application is listening for target\n"
		"  control if everything succeeded.\n"
		":rtype: ExecuteResult\n"
		"\n"
		"" },
  { "TakeOwnershipCapture", (PyCFunction) _wrap_RemoteServer_TakeOwnershipCapture, METH_O, (char *) "\n"
		"TakeOwnershipCapture(filename)\n"
		"\n"
		"Take ownership over a capture file.\n"
		"\n"
		"Initially when a capture is made, it is owned by the injected library in the application. It passes\n"
		"ownership to any program that is connected via target control that is notified about the capture,\n"
		"which is then responsible for either saving the file or deleting it if it's unwanted.\n"
		"\n"
		"Passing ownership of a file to the remote server means that it will be kept around for future use\n"
		"until the server closes, at which point it will delete any files it owns.\n"
		"\n"
		":param str filename: The remote path to take ownership of.\n"
		"\n"
		"" },
  { "CopyCaptureToRemote", (PyCFunction) _wrap_RemoteServer_CopyCaptureToRemote, METH_VARARGS, (char *) "\n"
		"CopyCaptureToRemote(filename, progress)\n"
		"\n"
		"Copy a capture file that is stored on the local system to the remote system.\n"
		"\n"
		"This function will block until the copy is fully complete, or an error has occurred.\n"
		"\n"
		"This is primarily useful for when a capture is only stored locally and must be replayed remotely, as\n"
		"the capture must be available on the machine where the replay happens.\n"
		"\n"
		":param str filename: The path to the file on the local system.\n"
		":param ProgressCallback progress: A callback that will be repeatedly called with an updated progress\n"
		"  value for the copy. Can be ``None`` if no progress is desired.\n"
		"  Callback function signature must match :func:`ProgressCallback`.\n"
		":return: The path on the remote system where the capture was saved temporarily.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "CopyCaptureFromRemote", (PyCFunction) _wrap_RemoteServer_CopyCaptureFromRemote, METH_VARARGS, (char *) "\n"
		"CopyCaptureFromRemote(remotepath, localpath, progress)\n"
		"\n"
		"Copy a capture file that is stored on the remote system to the local system.\n"
		"\n"
		"This function will block until the copy is fully complete, or an error has occurred.\n"
		"\n"
		":param str remotepath: The remote path where the file should be copied from.\n"
		":param str localpath: The local path where the file should be saved.\n"
		":param ProgressCallback progress: A callback that will be repeatedly called with an updated progress\n"
		"  value for the copy. Can be ``None`` if no progress is desired.\n"
		"  Callback function signature must match :func:`ProgressCallback`.\n"
		"\n"
		"" },
  { "OpenCapture", (PyCFunction) _wrap_RemoteServer_OpenCapture, METH_VARARGS, (char *) "\n"
		"OpenCapture(proxyid, logfile, opts, progress)\n"
		"\n"
		"Open a capture file for remote capture and replay. The capture will be opened and\n"
		"replayed on the remote system, and proxied to the local system with a given renderer. As much work\n"
		"as possible will happen locally to save on bandwidth, processing and latency.\n"
		"\n"
		"This function will block until the capture is fully opened on the remote system and ready for use,\n"
		"or an error has occurred.\n"
		"\n"
		".. note:: You *must* close the resulting :class:`ReplayController` with the :meth:`CloseCapture`\n"
		"  function to ensure the local proxy is correctly tidied up, instead of using\n"
		"  :meth:`ReplayController.Shutdown`.\n"
		"\n"
		":param int proxyid: The index in the array returned by :meth:`LocalProxies` to use as a local proxy,\n"
		"  or :data:`NoPreference` to indicate no preference for any proxy.\n"
		":param str logfile: The path on the remote system where the file is. If the file is only available\n"
		"  locally you can use :meth:`CopyCaptureToRemote` to transfer it over the remote connection.\n"
		":param ReplayOptions opts: The options controlling how the capture should be replayed.\n"
		":param ProgressCallback progress: A callback that will be repeatedly called with an updated progress\n"
		"  value for the opening. Can be ``None`` if no progress is desired.\n"
		"  Callback function signature must match :func:`ProgressCallback`.\n"
		":return: A tuple containing the status of opening the capture, whether success or failure, and the\n"
		"  resulting :class:`ReplayController` handle if successful.\n"
		":rtype: Tuple[ResultDetails,ReplayController]\n"
		"\n"
		"" },
  { "CloseCapture", (PyCFunction) _wrap_RemoteServer_CloseCapture, METH_O, (char *) "\n"
		"CloseCapture(rend)\n"
		"\n"
		"Close a capture analysis handle previously opened by :meth:`OpenCapture`.\n"
		"\n"
		":param ReplayController rend: The ReplayController that is to be closed.\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__IRemoteServer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.RemoteServer",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__IRemoteServer_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__IRemoteServer_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__IRemoteServer_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__IRemoteServer_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A connection to a running remote RenderDoc server on another machine. This allows the\n"
		"transfer of captures to and from the local machine, as well as remotely replaying a capture with a\n"
		"local proxy renderer, so that captures that are not supported locally can still be debugged with as\n"
		"much work as possible happening on the local machine.\n"
		"\n"
		".. data:: NoPreference\n"
		"\n"
		"  No preference for a particular value, see :meth:`ReplayController.DebugPixel`.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__IRemoteServer_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__IRemoteServer_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__IRemoteServer_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__IRemoteServer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__IRemoteServer_type};

static SwigPyGetSet CaptureFile___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ICaptureFile_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ICaptureFile.__dict__", (void *) &CaptureFile___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ICaptureFile_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ICaptureFile_methods[] = {
  { "Shutdown", (PyCFunction) _wrap_CaptureFile_Shutdown, METH_NOARGS, (char *) "\n"
		"Shutdown()\n"
		"\n"
		"Closes the file handle.\n"
		"" },
  { "OpenFile", (PyCFunction) _wrap_CaptureFile_OpenFile, METH_VARARGS, (char *) "\n"
		"OpenFile(filename, filetype, progress)\n"
		"\n"
		"Initialises the capture handle from a file.\n"
		"\n"
		"This method supports converting from non-native representations via structured data, by specifying\n"
		"the input format in the :paramref:`OpenFile.filetype` parameter. The list of supported formats can be retrieved\n"
		"by calling :meth:`GetCaptureFileFormats`.\n"
		"\n"
		"``rdc`` is guaranteed to always be a supported filetype, and will be assumed if the filetype is\n"
		"empty or unrecognised.\n"
		"\n"
		":param str filename: The filename of the file to open.\n"
		":param str filetype: The format of the given file.\n"
		":param ProgressCallback progress: A callback that will be repeatedly called with an updated progress\n"
		"  value if an import step occurs. Can be ``None`` if no progress is desired.\n"
		"  Callback function signature must match :func:`ProgressCallback`.\n"
		":return: The result of the operation.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { "OpenBuffer", (PyCFunction) _wrap_CaptureFile_OpenBuffer, METH_VARARGS, (char *) "\n"
		"OpenBuffer(buffer, filetype, progress)\n"
		"\n"
		"Initialises the file handle from a raw memory buffer.\n"
		"\n"
		"This may be useful if you don't want to parse the whole file or already have the file in memory.\n"
		"\n"
		"For the :paramref:`OpenBuffer.filetype` parameter, see :meth:`OpenFile`.\n"
		"\n"
		":param bytes buffer: The buffer containing the data to process.\n"
		":param str filetype: The format of the given file.\n"
		":param ProgressCallback progress: A callback that will be repeatedly called with an updated progress\n"
		"  value if an import step occurs. Can be ``None`` if no progress is desired.\n"
		"  Callback function signature must match :func:`ProgressCallback`.\n"
		":return: The result of the operation.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { "CopyFileTo", (PyCFunction) _wrap_CaptureFile_CopyFileTo, METH_O, (char *) "\n"
		"CopyFileTo(filename)\n"
		"\n"
		"When a capture file is opened, an exclusive lock is held on the file on disk. This\n"
		"makes it impossible to copy the file to another location at the user's request. Calling this\n"
		"function will copy the file on disk to a new location but otherwise won't affect the capture handle.\n"
		"The new file will be locked, the old file will be unlocked - to allow deleting if necessary.\n"
		"\n"
		"It is invalid to call this function if :meth:`OpenFile` has not previously been called to open the\n"
		"file.\n"
		"\n"
		":param str filename: The filename to copy to.\n"
		":return: The result of the file copy operation.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { "Convert", (PyCFunction) _wrap_CaptureFile_Convert, METH_VARARGS, (char *) "\n"
		"Convert(filename, filetype, file, progress)\n"
		"\n"
		"Converts the currently loaded file to a given format and saves it to disk.\n"
		"\n"
		"This allows converting a native RDC to another representation, or vice-versa converting another\n"
		"representation back to native RDC.\n"
		"\n"
		":param str filename: The filename to save to.\n"
		":param str filetype: The format to convert to.\n"
		":param SDFile file: An optional :class:`SDFile` with the structured data to source from. This is\n"
		"  useful in case the format specifies that it doesn't need buffers, and you already have a\n"
		"  :class:`ReplayController` open with the structured data. This saves the need to load the file\n"
		"  again. If ``None`` then structured data will be fetched if not already present and used.\n"
		":param ProgressCallback progress: A callback that will be repeatedly called with an updated progress\n"
		"  value for the conversion. Can be ``None`` if no progress is desired.\n"
		"  Callback function signature must match :func:`ProgressCallback`.\n"
		":return: The result of the operation.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { "GetCaptureFileFormats", (PyCFunction) _wrap_CaptureFile_GetCaptureFileFormats, METH_NOARGS, (char *) "\n"
		"GetCaptureFileFormats()\n"
		"\n"
		"Returns the list of capture file formats.\n"
		"\n"
		":return: The list of capture file formats available.\n"
		":rtype: List[CaptureFileFormat]\n"
		"\n"
		"" },
  { "LocalReplaySupport", (PyCFunction) _wrap_CaptureFile_LocalReplaySupport, METH_NOARGS, (char *) "\n"
		"LocalReplaySupport()\n"
		"\n"
		"Queries for how well a particular capture is supported on the local machine.\n"
		"\n"
		"If the file was opened with a format other than native ``rdc`` this will always return no\n"
		"replay support.\n"
		"\n"
		":return: How much support for replay exists locally.\n"
		":rtype: ReplaySupport\n"
		"\n"
		"" },
  { "RecordedMachineIdent", (PyCFunction) _wrap_CaptureFile_RecordedMachineIdent, METH_NOARGS, (char *) "\n"
		"RecordedMachineIdent()\n"
		"\n"
		"Retrieves the identifying string describing what type of machine created this capture.\n"
		"\n"
		":return: A string identifying the machine ident used to make the capture.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "TimestampBase", (PyCFunction) _wrap_CaptureFile_TimestampBase, METH_NOARGS, (char *) "\n"
		"TimestampBase()\n"
		"\n"
		"Retrieves the timestamp basis that all timestamps in the capture are relative to. May\n"
		"be 0 if all timestamps are already absolute.\n"
		"\n"
		":return: The timestamp base value\n"
		":rtype: int\n"
		"\n"
		"" },
  { "TimestampFrequency", (PyCFunction) _wrap_CaptureFile_TimestampFrequency, METH_NOARGS, (char *) "\n"
		"TimestampFrequency()\n"
		"\n"
		"Retrieves frequency for timestamps and durations to be divided by to convert to\n"
		"microseconds. May be 1.0 if all timestamps and durations are already in microseconds.\n"
		"\n"
		":return: The timestamp frequency\n"
		":rtype: float\n"
		"\n"
		"" },
  { "SetMetadata", (PyCFunction) _wrap_CaptureFile_SetMetadata, METH_VARARGS, (char *) "\n"
		"SetMetadata(driverName, machineIdent, thumbType, thumbWidth, thumbHeight, thumbData, timeBase, timeFreq)\n"
		"\n"
		"Sets the matadata for this capture handle.\n"
		"\n"
		"This function may only be called if the handle is 'empty' - i.e. no file has been opened with\n"
		":meth:`OpenFile` or :meth:`OpenBuffer`.\n"
		"\n"
		".. note:: The only supported values for :paramref:`SetMetadata.thumbType` are :attr:`FileType.JPG`,\n"
		"  :attr:`FileType.PNG`, :attr:`FileType.TGA`, and :attr:`FileType.BMP`.\n"
		"\n"
		":param str driverName: The name of the driver. Must be a recognised driver name (even if replay\n"
		"  support for that driver is not compiled in locally.\n"
		":param int machineIdent: The encoded machine identity value. Optional value and can be left to 0, as\n"
		"  the bits to set are internally defined, so only generally useful if copying a machine ident from\n"
		"  an existing capture.\n"
		":param FileType thumbType: The file type of the thumbnail. Ignored if\n"
		"  :paramref:`SetMetadata.thumbData` is empty.\n"
		":param int thumbWidth: The width of the thumbnail. Ignored if :paramref:`SetMetadata.thumbData` is\n"
		"  empty.\n"
		":param int thumbHeight: The height of the thumbnail. Ignored if :paramref:`SetMetadata.thumbData` is\n"
		"  empty.\n"
		":param bytes thumbData: The raw data of the thumbnail. If empty, no thumbnail is set.\n"
		":param int timeBase: The base value for timestamps in the capture. Can be set to 0 to indicate that\n"
		"  timestamps are already capture relative.\n"
		":param float timeFreq: The frequency for timestamps and durations to be divided by to convert to\n"
		"  microseconds. Can be set to 1.0 to indicate that timestamps and durations are already in\n"
		"  microseconds.\n"
		"\n"
		"" },
  { "OpenCapture", (PyCFunction) _wrap_CaptureFile_OpenCapture, METH_VARARGS, (char *) "\n"
		"OpenCapture(opts, progress)\n"
		"\n"
		"Opens a capture for replay locally and returns a handle to the capture. Only supported\n"
		"for handles opened with a native ``rdc`` capture, otherwise this will fail.\n"
		"\n"
		"This function will block until the capture is fully loaded and ready.\n"
		"\n"
		"Once the replay is created, this :class:`CaptureFile` can be shut down, there is no dependency on it\n"
		"by the :class:`ReplayController`.\n"
		"\n"
		":param ReplayOptions opts: The options controlling how the capture should be replayed.\n"
		":param ProgressCallback progress: A callback that will be repeatedly called with an updated progress\n"
		"  value for the opening. Can be ``None`` if no progress is desired.\n"
		"  Callback function signature must match :func:`ProgressCallback`.\n"
		":return: A tuple containing the status of opening the capture, whether success or failure, and the\n"
		"  resulting :class:`ReplayController` handle if successful.\n"
		":rtype: Tuple[ResultDetails,ReplayController]\n"
		"\n"
		"" },
  { "GetStructuredData", (PyCFunction) _wrap_CaptureFile_GetStructuredData, METH_NOARGS, (char *) "\n"
		"GetStructuredData()\n"
		"\n"
		"Returns the structured data for this capture.\n"
		"\n"
		"The lifetime of this data is scoped to the lifetime of the capture handle, so it cannot be used\n"
		"after the handle is destroyed.\n"
		"\n"
		":return: The structured data representing the file.\n"
		":rtype: SDFile\n"
		"\n"
		"" },
  { "SetStructuredData", (PyCFunction) _wrap_CaptureFile_SetStructuredData, METH_O, (char *) "\n"
		"SetStructuredData(file)\n"
		"\n"
		"Sets the structured data for this capture.\n"
		"\n"
		"This allows calling code to populate a capture out of generated structured data. In combination with\n"
		":meth:`SetMetadata` this allows a purely in-memory creation of a file to be saved out with\n"
		":meth:`Convert`.\n"
		"\n"
		"The data is copied internally so it can be destroyed after calling this function.\n"
		"\n"
		":param SDFile file: The structured data representing the file.\n"
		"\n"
		"" },
  { "GetThumbnail", (PyCFunction) _wrap_CaptureFile_GetThumbnail, METH_VARARGS, (char *) "\n"
		"GetThumbnail(type, maxsize)\n"
		"\n"
		"Retrieves the embedded thumbnail from the capture.\n"
		"\n"
		".. note:: The only supported values for :paramref:`GetThumbnail.type` are :attr:`FileType.JPG`,\n"
		"  :attr:`FileType.PNG`, :attr:`FileType.TGA`, and :attr:`FileType.BMP`.\n"
		"\n"
		":param FileType type: The image format to convert the thumbnail to.\n"
		":param int maxsize: The largest width or height allowed. If the thumbnail is larger, it's resized.\n"
		":return: The raw contents of the thumbnail, converted to the desired type at the desired max\n"
		"  resolution.\n"
		":rtype: Thumbnail\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ICaptureFile_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.CaptureFile",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ICaptureFile_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__ICaptureFile_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__ICaptureFile_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ICaptureFile_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A handle to a capture file. Used for simple cheap processing and meta-data fetching\n"
		"without opening the capture for analysis.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ICaptureFile_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ICaptureFile_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ICaptureFile_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ICaptureFile_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ICaptureFile_type};

static SwigPyGetSet Camera___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ICamera_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ICamera.__dict__", (void *) &Camera___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ICamera_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ICamera_methods[] = {
  { "Shutdown", (PyCFunction) _wrap_Camera_Shutdown, METH_NOARGS, (char *) "\n"
		"Shutdown()\n"
		"\n"
		"Closes the camera handle.\n"
		"" },
  { "SetNearFar", (PyCFunction) _wrap_Camera_SetNearFar, METH_VARARGS, (char *) "\n"
		"SetNearFar(n, f)\n"
		"\n"
		"Sets the near and far plane for the camera's display.\n"
		"\n"
		"The default value is ``0.1 - 100000.0`` if these are not set explicitly.\n"
		"\n"
		":param float n: The near plane.\n"
		":param float f: The far plane.\n"
		"\n"
		"" },
  { "SetPosition", (PyCFunction) _wrap_Camera_SetPosition, METH_VARARGS, (char *) "\n"
		"SetPosition(x, y, z)\n"
		"\n"
		"Sets the position for the camera, either arcball or FPS.\n"
		"\n"
		"For arcball cameras, this sets the lookat position at the centre of the arcball.\n"
		"\n"
		"For FPS look cameras, this sets the position of the camera in space.\n"
		"\n"
		":param float x: The X co-ordinate of the position.\n"
		":param float y: The Y co-ordinate of the position.\n"
		":param float z: The Z co-ordinate of the position.\n"
		"\n"
		"" },
  { "SetFPSRotation", (PyCFunction) _wrap_Camera_SetFPSRotation, METH_VARARGS, (char *) "\n"
		"SetFPSRotation(x, y, z)\n"
		"\n"
		"Sets the rotation for an FPS camera.\n"
		"\n"
		"It is invalid to call this function for arcball cameras.\n"
		"\n"
		":param float x: The rotation around the X axis (pitch).\n"
		":param float y: The rotation around the Y axis (yaw).\n"
		":param float z: The rotation around the Z axis (roll).\n"
		"\n"
		"" },
  { "SetArcballDistance", (PyCFunction) _wrap_Camera_SetArcballDistance, METH_O, (char *) "\n"
		"SetArcballDistance(dist)\n"
		"\n"
		"Sets the distance in units the arcball camera sits away from the lookat position.\n"
		"\n"
		":param float dist: The distance of the camera from the lookat position.\n"
		"\n"
		"" },
  { "ResetArcball", (PyCFunction) _wrap_Camera_ResetArcball, METH_NOARGS, (char *) "\n"
		"ResetArcball()\n"
		"\n"
		"Reset the arcball to defaults.\n"
		"" },
  { "RotateArcball", (PyCFunction) _wrap_Camera_RotateArcball, METH_VARARGS, (char *) "\n"
		"RotateArcball(ax, ay, bx, by)\n"
		"\n"
		"Rotates the arcball based on relative window co-ordinates.\n"
		"\n"
		"The co-ordinates are in pixels and represent the old/new co-ordinates of the mouse cursor over the\n"
		"drag.\n"
		"\n"
		":param float ax: The X co-ordinate of the previous mouse position.\n"
		":param float ay: The Y co-ordinate of the previous mouse position.\n"
		":param float bx: The X co-ordinate of the new mouse position.\n"
		":param float by: The Y co-ordinate of the new mouse position.\n"
		"\n"
		"" },
  { "GetPosition", (PyCFunction) _wrap_Camera_GetPosition, METH_NOARGS, (char *) "\n"
		"GetPosition()\n"
		"\n"
		"Retrieves the position of the camera\n"
		"\n"
		":return: The position vector of the camera. W is set to 1\n"
		":rtype: FloatVector\n"
		"\n"
		"" },
  { "GetForward", (PyCFunction) _wrap_Camera_GetForward, METH_NOARGS, (char *) "\n"
		"GetForward()\n"
		"\n"
		"Retrieves the forward vector of the camera, in the positive Z direction.\n"
		"\n"
		":return: The forward vector of the camera. W is set to 1\n"
		":rtype: FloatVector\n"
		"\n"
		"" },
  { "GetRight", (PyCFunction) _wrap_Camera_GetRight, METH_NOARGS, (char *) "\n"
		"GetRight()\n"
		"\n"
		"Retrieves the right vector of the camera, in the positive X direction.\n"
		"\n"
		":return: The right vector of the camera. W is set to 1\n"
		":rtype: FloatVector\n"
		"\n"
		"" },
  { "GetUp", (PyCFunction) _wrap_Camera_GetUp, METH_NOARGS, (char *) "\n"
		"GetUp()\n"
		"\n"
		"Retrieves the up vector of the camera, in the positive Y direction.\n"
		"\n"
		":return: The up vector of the camera. W is set to 1\n"
		":rtype: FloatVector\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ICamera_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.Camera",                       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ICamera_type.as_number,   /* tp_as_number */
    &SwigPyBuiltin__ICamera_type.as_sequence, /* tp_as_sequence */
    &SwigPyBuiltin__ICamera_type.as_mapping,  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ICamera_type.as_buffer,   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A handle to a camera controller, used for user interaction and controlling a view of a\n"
		"3D scene.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ICamera_richcompare,             /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ICamera_methods,           /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ICamera_getset,            /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ICamera_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ICamera_type};

static SwigPyGetSet VulkanLayerRegistrationInfo___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VulkanLayerRegistrationInfo_flags_getset = { _wrap_VulkanLayerRegistrationInfo_flags_get, _wrap_VulkanLayerRegistrationInfo_flags_set };
static SwigPyGetSet VulkanLayerRegistrationInfo_myJSONs_getset = { _wrap_VulkanLayerRegistrationInfo_myJSONs_get, _wrap_VulkanLayerRegistrationInfo_myJSONs_set };
static SwigPyGetSet VulkanLayerRegistrationInfo_otherJSONs_getset = { _wrap_VulkanLayerRegistrationInfo_otherJSONs_get, _wrap_VulkanLayerRegistrationInfo_otherJSONs_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VulkanLayerRegistrationInfo_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VulkanLayerRegistrationInfo.__dict__", (void *) &VulkanLayerRegistrationInfo___dict___getset }
,
    { (char *) "flags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		":class:`VulkanLayerFlags` detailing the current registration.\n"
		"\n"
		":type: VulkanLayerFlags\n"
		"\n"
		"", (void *) &VulkanLayerRegistrationInfo_flags_getset }
,
    { (char *) "myJSONs", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list of jsons that should be registered\n"
		"\n"
		":type: List[str]\n"
		"\n"
		"", (void *) &VulkanLayerRegistrationInfo_myJSONs_getset }
,
    { (char *) "otherJSONs", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list of jsons that should be unregistered / updated\n"
		"\n"
		":type: List[str]\n"
		"\n"
		"", (void *) &VulkanLayerRegistrationInfo_otherJSONs_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VulkanLayerRegistrationInfo_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VulkanLayerRegistrationInfo_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VulkanLayerRegistrationInfo_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VulkanLayerRegistrationInfo",  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VulkanLayerRegistrationInfo_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VulkanLayerRegistrationInfo_type.as_number,   /* tp_as_number */
    &SwigPyBuiltin__VulkanLayerRegistrationInfo_type.as_sequence, /* tp_as_sequence */
    &SwigPyBuiltin__VulkanLayerRegistrationInfo_type.as_mapping,  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VulkanLayerRegistrationInfo_type.as_buffer,   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "INTERNAL: Information about vulkan layer registration",      /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VulkanLayerRegistrationInfo_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VulkanLayerRegistrationInfo_methods,           /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VulkanLayerRegistrationInfo_getset,            /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VulkanLayerRegistrationInfo,             /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VulkanLayerRegistrationInfo_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VulkanLayerRegistrationInfo_type};

static SwigPyGetSet DeviceProtocolController___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__IDeviceProtocolController_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"IDeviceProtocolController.__dict__", (void *) &DeviceProtocolController___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__IDeviceProtocolController_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__IDeviceProtocolController_methods[] = {
  { "GetProtocolName", (PyCFunction) _wrap_DeviceProtocolController_GetProtocolName, METH_NOARGS, (char *) "\n"
		"GetProtocolName()\n"
		"\n"
		"Retrieves the name of this protocol as passed to :func:`GetDeviceProtocolController`.\n"
		"\n"
		":return: A string identifying the protocol.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "GetDevices", (PyCFunction) _wrap_DeviceProtocolController_GetDevices, METH_NOARGS, (char *) "\n"
		"GetDevices()\n"
		"\n"
		"Returns a list of devices currently available through the given protocol.\n"
		"\n"
		"Until a device is enumerated through this function it may not be available for connection through\n"
		"other methods such as target control or remote server access, even if the device is physically\n"
		"connected, due to initialisation happening only when enumerated.\n"
		"\n"
		"The returned string is the hostname of the device, which can be connected via\n"
		"``protocol://hostname`` with interfaces that take a hostname.\n"
		"\n"
		":return: A list of the devices currently available.\n"
		":rtype: List[str]\n"
		"\n"
		"" },
  { "GetFriendlyName", (PyCFunction) _wrap_DeviceProtocolController_GetFriendlyName, METH_O, (char *) "\n"
		"GetFriendlyName(URL)\n"
		"\n"
		"Retrieves the user friendly name of the given device. This may be easier for a user to\n"
		"correlate to a device than the hostname which may be only a programmatic identifier.\n"
		"\n"
		":param str URL: The URL of the device in the form ``protocol://host``, with protocol as returned by\n"
		"  :func:`GetProtocolName` and host as returned by :func:`GetDevices`.\n"
		":return: A string identifying the device.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "SupportsMultiplePrograms", (PyCFunction) _wrap_DeviceProtocolController_SupportsMultiplePrograms, METH_O, (char *) "\n"
		"SupportsMultiplePrograms(URL)\n"
		"\n"
		"Query if the device supports multiple programs running and being captured. If not, the\n"
		"user can be prompted to close an existing program before a new one is launched.\n"
		"\n"
		":param str URL: The URL of the device in the form ``protocol://host``, with protocol as returned by\n"
		"  :func:`GetProtocolName` and host as returned by :func:`GetDevices`.\n"
		":return: ``True`` if the device supports multiple programs, ``False`` otherwise.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "IsSupported", (PyCFunction) _wrap_DeviceProtocolController_IsSupported, METH_O, (char *) "\n"
		"IsSupported(URL)\n"
		"\n"
		"Query if the device supports RenderDoc capture and replay.\n"
		"\n"
		":param str URL: The URL of the device in the form ``protocol://host``, with protocol as returned by\n"
		"  :func:`GetProtocolName` and host as returned by :func:`GetDevices`.\n"
		":return: ``True`` if any the device is supported, ``False`` otherwise.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "StartRemoteServer", (PyCFunction) _wrap_DeviceProtocolController_StartRemoteServer, METH_O, (char *) "\n"
		"StartRemoteServer(URL)\n"
		"\n"
		"Start the remote server running on the given device.\n"
		"\n"
		":param str URL: The URL of the device in the form ``protocol://host``, with protocol as returned by\n"
		"  :func:`GetProtocolName` and host as returned by :func:`GetDevices`.\n"
		":return: The status of starting the server, whether success or failure.\n"
		":rtype: ResultDetails\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__IDeviceProtocolController_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.DeviceProtocolController",     /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__IDeviceProtocolController_type.as_number,     /* tp_as_number */
    &SwigPyBuiltin__IDeviceProtocolController_type.as_sequence,   /* tp_as_sequence */
    &SwigPyBuiltin__IDeviceProtocolController_type.as_mapping,    /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__IDeviceProtocolController_type.as_buffer,     /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "An interface for enumerating and controlling remote devices.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__IDeviceProtocolController_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__IDeviceProtocolController_methods,             /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__IDeviceProtocolController_getset,              /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__IDeviceProtocolController_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__IDeviceProtocolController_type};

static SwigPyGetSet ResourceId___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ResourceId_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ResourceId.__dict__", (void *) &ResourceId___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ResourceId_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ResourceId___eq__(self, other); break;
    case Py_LT : result = _wrap_ResourceId___lt__(self, other); break;
    case Py_NE : result = _wrap_ResourceId___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ResourceId_methods[] = {
  { "Null", (PyCFunction) _wrap_ResourceId_Null, METH_STATIC|METH_NOARGS, (char *) "\n"
		"Null()\n"
		"\n"
		"A helper function that explicitly creates an empty/invalid/null :class:`ResourceId`.\n"
		"\n"
		":return: an empty/invalid/null :class:`ResourceId`.\n"
		":rtype: ResourceId\n"
		"\n"
		"" },
  { "__lt__", (PyCFunction) _wrap_ResourceId___lt__, METH_O, (char *) "__lt__(other)" },
  { "__eq__", (PyCFunction) _wrap_ResourceId___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_ResourceId___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ResourceId_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ResourceId",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ResourceId_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) resid_str,                     /* tp_repr */
    &SwigPyBuiltin__ResourceId_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__ResourceId_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__ResourceId_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) resid_hash,                    /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) resid_str,                     /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ResourceId_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"This is an opaque identifier that uniquely locates a resource.\n"
		"\n"
		".. note::\n"
		"  These IDs do not overlap ever - textures, buffers, shaders and samplers will all have unique IDs\n"
		"  and do not reuse the namespace. The IDs assigned for resources during capture are also used\n"
		"  during replay. Any internal/synthesised resources created during replay will have distinct IDs.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ResourceId_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ResourceId_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ResourceId_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ResourceId,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) resid_int,                    /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ResourceId_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ResourceId_type};

static SwigPyGetSet SDBasic___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SDBasic_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SDBasic.__dict__", (void *) &SDBasic___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SDBasic_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SDBasic_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SDBasic_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "SDBasic",                                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_SDBasic_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SDBasic_type.as_number,   /* tp_as_number */
    &SwigPyBuiltin__SDBasic_type.as_sequence, /* tp_as_sequence */
    &SwigPyBuiltin__SDBasic_type.as_mapping,  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SDBasic_type.as_buffer,   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The basic irreducible type of an object. Every other more complex type is built on these.\n"
		"\n"
		".. data:: Chunk\n"
		"\n"
		"  A 'special' type indicating that the object is a chunk. A chunk can be treated like a\n"
		"  :data:`Struct` otherwise. See :class:`SDChunk`.\n"
		"\n"
		".. data:: Struct\n"
		"\n"
		"  A composite type with some number of children of different types, each child with its own name.\n"
		"  May in some cases be empty, so the presence of children should not be assumed.\n"
		"\n"
		".. data:: Array\n"
		"\n"
		"  A composite type with some number of children with an identical type and referred to purely by\n"
		"  their index in the array. May be empty.\n"
		"\n"
		".. data:: Null\n"
		"\n"
		"  An indicator that an object could be here, but is optional and is currently not present. See\n"
		"  :data:`SDTypeFlags.Nullable`.\n"
		"\n"
		".. data:: Buffer\n"
		"\n"
		"  An opaque byte buffer.\n"
		"\n"
		".. data:: String\n"
		"\n"
		"  A string, encoded as UTF-8.\n"
		"\n"
		".. data:: Enum\n"
		"\n"
		"  An enum value - stored as an integer but with a distinct set of possible named values.\n"
		"\n"
		".. data:: UnsignedInteger\n"
		"\n"
		"  An unsigned integer.\n"
		"\n"
		".. data:: SignedInteger\n"
		"\n"
		"  An signed integer.\n"
		"\n"
		".. data:: Float\n"
		"\n"
		"  A floating point value.\n"
		"\n"
		".. data:: Boolean\n"
		"\n"
		"  A boolean true/false value.\n"
		"\n"
		".. data:: Character\n"
		"\n"
		"  A single byte character. Wide/multi-byte characters are not supported (these would be stored as a\n"
		"  string with 1 character and multiple bytes in UTF-8).\n"
		"\n"
		".. data:: Resource\n"
		"\n"
		"  A ResourceId. Equivalent to (and stored as) an 8-byte unsigned integer, but specifically contains\n"
		"  the unique Id of a resource in a capture.\n"
		"\n"
		".. data:: GPUAddress\n"
		"\n"
		"  A GPU pointer. Equivalent to (and stored as) an 8-byte unsigned integer, but specifically contains\n"
		"  the address of a resource in a capture.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SDBasic_richcompare,             /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SDBasic_methods,           /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SDBasic_getset,            /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_SDBasic,             /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SDBasic_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SDBasic_type};

static SwigPyGetSet SDTypeFlags___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SDTypeFlags_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SDTypeFlags.__dict__", (void *) &SDTypeFlags___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SDTypeFlags_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SDTypeFlags_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SDTypeFlags_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "SDTypeFlags",                            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_SDTypeFlags_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SDTypeFlags_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__SDTypeFlags_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__SDTypeFlags_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SDTypeFlags_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Bitfield flags that could be applied to a type.\n"
		"\n"
		".. data:: NoFlags\n"
		"\n"
		"  This type has no special properties.\n"
		"\n"
		".. data:: HasCustomString\n"
		"\n"
		"  This type has a custom string. This could be used for example for enums, to display the string\n"
		"  value of the enum as well as the integer storage, or perhaps for opaque types that should be\n"
		"  displayed to the user as a string even if the underlying representation is not a string.\n"
		"\n"
		".. data:: Hidden\n"
		"\n"
		"  This type is considered an implementation detail and should not typically be displayed to the user.\n"
		"\n"
		".. data:: Nullable\n"
		"\n"
		"  This type is nullable and can sometimes be removed and replaced simply with a Null type. See\n"
		"  :data:`SDBasic.Null`.\n"
		"\n"
		".. data:: NullString\n"
		"\n"
		"  Special flag to indicate that this is a C-string which was NULL, not just empty.\n"
		"\n"
		".. data:: FixedArray\n"
		"\n"
		"  Special flag to indicate that this is array was a fixed-size real array, rather than a complex\n"
		"  container type or a pointer & length.\n"
		"\n"
		".. data:: Union\n"
		"\n"
		"  Special flag to indicate that this is structure is stored as a union, meaning all children share\n"
		"  the same memory and some external flag indicates which element is valid.\n"
		"\n"
		".. data:: Important\n"
		"\n"
		"  Indicates that this object is important or significant, to aid in generating a summary/one-line\n"
		"  view of a particular chunk by only including important children.\n"
		"\n"
		"  This property can be recursive - so an important child which is a structure can have only some\n"
		"  members which are important.\n"
		"\n"
		".. data:: ImportantChildren\n"
		"\n"
		"  Indicates that only important children should be processed, as noted in :data:`Important`. This\n"
		"  may appear on an object which has no important children - which indicates explicitly that there\n"
		"  are no important children so when summarising no parameters should be shown.\n"
		"\n"
		".. data:: HiddenChildren\n"
		"\n"
		"  Indicates that some children are marked as hidden. This can be important for cases where the\n"
		"  number of children is important.\n"
		"\n"
		".. data:: OffsetOrSize\n"
		"\n"
		"  Special flag to indicate that this type will be used as a byte offset or byte size, which is used to \n"
		"  control the formatting mode when the value is displayed in the UI.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SDTypeFlags_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SDTypeFlags_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SDTypeFlags_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_SDTypeFlags,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SDTypeFlags_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SDTypeFlags_type};

static SwigPyGetSet SDChunkFlags___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SDChunkFlags_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SDChunkFlags.__dict__", (void *) &SDChunkFlags___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SDChunkFlags_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SDChunkFlags_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SDChunkFlags_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "SDChunkFlags",                           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_SDChunkFlags_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SDChunkFlags_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__SDChunkFlags_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__SDChunkFlags_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SDChunkFlags_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Bitfield flags that could be applied to an :class:`SDChunk`.\n"
		"\n"
		".. data:: NoFlags\n"
		"\n"
		"  This chunk has no special properties.\n"
		"\n"
		".. data:: OpaqueChunk\n"
		"\n"
		"  This chunk wasn't supported for decoding or was skipped for another reason and was detailed as\n"
		"  an opaque byte stream. It should be preserved as-is and will remain in native RDC format.\n"
		"\n"
		".. data:: HasCallstack\n"
		"\n"
		"  This chunk has a callstack. Used to indicate the presence of a callstack even if it's empty\n"
		"  (perhaps due to failure to collect the stack frames).\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SDChunkFlags_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SDChunkFlags_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SDChunkFlags_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_SDChunkFlags,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SDChunkFlags_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SDChunkFlags_type};

static SwigPyGetSet SDType_name_getset = { _wrap_SDType_name_get, _wrap_SDType_name_set };
static SwigPyGetSet SDType___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet SDType_byteSize_getset = { _wrap_SDType_byteSize_get, _wrap_SDType_byteSize_set };
static SwigPyGetSet SDType_basetype_getset = { _wrap_SDType_basetype_get, _wrap_SDType_basetype_set };
static SwigPyGetSet SDType_flags_getset = { _wrap_SDType_flags_get, _wrap_SDType_flags_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SDType_getset[] = {
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of this type.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &SDType_name_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SDType.__dict__", (void *) &SDType___dict___getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size in bytes that an instance of this type takes up.\n"
		"\n"
		"This is only valid for whole chunks (where it contains the whole chunk size), for buffers that have\n"
		"an arbitrary size, or for basic types such as integers and floating point values where it gives the\n"
		"size/precision of the type.\n"
		"\n"
		"For variable size types like structs, arrays, etc it will be set to 0.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SDType_byteSize_getset }
,
    { (char *) "basetype", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`SDBasic` category that this type belongs to.\n"
		"\n"
		":type: SDBasic\n"
		"\n"
		"", (void *) &SDType_basetype_getset }
,
    { (char *) "flags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`SDTypeFlags` flags for this type.\n"
		"\n"
		":type: SDTypeFlags\n"
		"\n"
		"", (void *) &SDType_flags_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SDType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SDType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SDType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.SDType",                       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SDType_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__SDType_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__SDType_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SDType_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Details the name and properties of a structured type",       /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SDType_richcompare,              /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SDType_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SDType_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SDType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SDType_type};

static SwigPyGetSet SDChunkMetaData___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet SDChunkMetaData_durationMicro_getset = { _wrap_SDChunkMetaData_durationMicro_get, _wrap_SDChunkMetaData_durationMicro_set };
static SwigPyGetSet SDChunkMetaData_callstack_getset = { _wrap_SDChunkMetaData_callstack_get, _wrap_SDChunkMetaData_callstack_set };
static SwigPyGetSet SDChunkMetaData_length_getset = { _wrap_SDChunkMetaData_length_get, _wrap_SDChunkMetaData_length_set };
static SwigPyGetSet SDChunkMetaData_flags_getset = { _wrap_SDChunkMetaData_flags_get, _wrap_SDChunkMetaData_flags_set };
static SwigPyGetSet SDChunkMetaData_chunkID_getset = { _wrap_SDChunkMetaData_chunkID_get, _wrap_SDChunkMetaData_chunkID_set };
static SwigPyGetSet SDChunkMetaData_threadID_getset = { _wrap_SDChunkMetaData_threadID_get, _wrap_SDChunkMetaData_threadID_set };
static SwigPyGetSet SDChunkMetaData_timestampMicro_getset = { _wrap_SDChunkMetaData_timestampMicro_get, _wrap_SDChunkMetaData_timestampMicro_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SDChunkMetaData_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SDChunkMetaData.__dict__", (void *) &SDChunkMetaData___dict___getset }
,
    { (char *) "durationMicro", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The duration in microseconds that this chunk took. This is the time for the actual\n"
		"work, not the serialising.\n"
		"Since 0 is a possible value for this (for extremely fast calls), -1 is the invalid/not present value.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SDChunkMetaData_durationMicro_getset }
,
    { (char *) "callstack", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The frames of the CPU-side callstack leading up to the chunk.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &SDChunkMetaData_callstack_getset }
,
    { (char *) "length", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The length in bytes of this chunk - may be longer than the actual sum of the data if a\n"
		"conservative size estimate was used on creation to avoid seeking to fix-up the stored length.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SDChunkMetaData_length_getset }
,
    { (char *) "flags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`SDChunkFlags` for this chunk.\n"
		"\n"
		":type: SDChunkFlags\n"
		"\n"
		"", (void *) &SDChunkMetaData_flags_getset }
,
    { (char *) "chunkID", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The internal chunk ID - unique given a particular driver in use.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SDChunkMetaData_chunkID_getset }
,
    { (char *) "threadID", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The ID of the thread where this chunk was recorded.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SDChunkMetaData_threadID_getset }
,
    { (char *) "timestampMicro", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The point in time when this chunk was recorded, in microseconds since program start.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SDChunkMetaData_timestampMicro_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SDChunkMetaData_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SDChunkMetaData_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SDChunkMetaData_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.SDChunkMetaData",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SDChunkMetaData_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__SDChunkMetaData_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__SDChunkMetaData_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SDChunkMetaData_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The metadata that goes along with a :class:`SDChunk` to detail how it was recorded.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SDChunkMetaData_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SDChunkMetaData_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SDChunkMetaData_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SDChunkMetaData_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SDChunkMetaData_type};

static SwigPyGetSet SDObjectPODData_i_getset = { _wrap_SDObjectPODData_i_get, _wrap_SDObjectPODData_i_set };
static SwigPyGetSet SDObjectPODData_b_getset = { _wrap_SDObjectPODData_b_get, _wrap_SDObjectPODData_b_set };
static SwigPyGetSet SDObjectPODData_c_getset = { _wrap_SDObjectPODData_c_get, _wrap_SDObjectPODData_c_set };
static SwigPyGetSet SDObjectPODData___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet SDObjectPODData_d_getset = { _wrap_SDObjectPODData_d_get, _wrap_SDObjectPODData_d_set };
static SwigPyGetSet SDObjectPODData_id_getset = { _wrap_SDObjectPODData_id_get, _wrap_SDObjectPODData_id_set };
static SwigPyGetSet SDObjectPODData_u_getset = { _wrap_SDObjectPODData_u_get, _wrap_SDObjectPODData_u_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SDObjectPODData_getset[] = {
    { (char *) "i", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value as a signed integer.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SDObjectPODData_i_getset }
,
    { (char *) "b", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value as a boolean.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &SDObjectPODData_b_getset }
,
    { (char *) "c", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value as a single byte character.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &SDObjectPODData_c_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SDObjectPODData.__dict__", (void *) &SDObjectPODData___dict___getset }
,
    { (char *) "d", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value as a floating point number.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &SDObjectPODData_d_getset }
,
    { (char *) "id", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value as a :class:`ResourceId`\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &SDObjectPODData_id_getset }
,
    { (char *) "u", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value as an unsigned integer.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SDObjectPODData_u_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SDObjectPODData_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SDObjectPODData_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SDObjectPODData_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.SDObjectPODData",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SDObjectPODData_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__SDObjectPODData_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__SDObjectPODData_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SDObjectPODData_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The plain-old-data contents of an :class:`SDObject`.\n"
		"\n"
		"Only one member is valid, as defined by the type of the :class:`SDObject`.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SDObjectPODData_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SDObjectPODData_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SDObjectPODData_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SDObjectPODData_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SDObjectPODData_type};

static SwigPyGetSet StructuredObjectList___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__StructuredObjectList_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"StructuredObjectList.__dict__", (void *) &StructuredObjectList___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__StructuredObjectList_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__StructuredObjectList_methods[] = {
  { "append", (PyCFunction) _wrap_StructuredObjectList_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_StructuredObjectList_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_StructuredObjectList_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_StructuredObjectList_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_StructuredObjectList_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_StructuredObjectList_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_StructuredObjectList_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_StructuredObjectList_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_StructuredObjectList_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_StructuredObjectList_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_StructuredObjectList_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__StructuredObjectList_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.StructuredObjectList",         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_StructuredObjectList,     /* tp_repr */
    &SwigPyBuiltin__StructuredObjectList_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__StructuredObjectList_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__StructuredObjectList_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_StructuredObjectList,     /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__StructuredObjectList_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "INTERNAL: An array of SDObject*, mapped to a pure list in python",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__StructuredObjectList_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__StructuredObjectList_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__StructuredObjectList_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_StructuredObjectList,               /* mp_subscript */
    (objobjargproc) setsubscript_StructuredObjectList,            /* mp_ass_subscript */
  },
  {
    (lenfunc) length_StructuredObjectList,    /* sq_length */
    (binaryfunc) concat_StructuredObjectList, /* sq_concat */
    (ssizeargfunc) repeat_StructuredObjectList,                   /* sq_repeat */
    (ssizeargfunc) getitem_StructuredObjectList,                  /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_StructuredObjectList,               /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_StructuredObjectList,                 /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_StructuredObjectList,               /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__StructuredObjectList_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__StructuredObjectList_type};

static SwigPyGetSet SDObjectData___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet SDObjectData_string_getset = { _wrap_SDObjectData_string_get, _wrap_SDObjectData_string_set };
static SwigPyGetSet SDObjectData_basic_getset = { _wrap_SDObjectData_basic_get, _wrap_SDObjectData_basic_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SDObjectData_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SDObjectData.__dict__", (void *) &SDObjectData___dict___getset }
,
    { (char *) "string", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The string contents of the object.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &SDObjectData_string_getset }
,
    { (char *) "basic", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The plain-old data contents of the object, in a :class:`SDObjectPODData`.\n"
		"\n"
		":type: SDObjectPODData\n"
		"\n"
		"", (void *) &SDObjectData_basic_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SDObjectData_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SDObjectData_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SDObjectData_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.SDObjectData",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SDObjectData_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__SDObjectData_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__SDObjectData_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SDObjectData_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The data inside an :class:`SDObject` whether it's plain old data or complex children.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SDObjectData_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SDObjectData_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SDObjectData_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SDObjectData_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SDObjectData_type};

static SwigPyGetSet SDObject_name_getset = { _wrap_SDObject_name_get, _wrap_SDObject_name_set };
static SwigPyGetSet SDObject_data_getset = { _wrap_SDObject_data_get, 0 };
static SwigPyGetSet SDObject___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet SDObject_type_getset = { _wrap_SDObject_type_get, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SDObject_getset[] = {
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of this object.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &SDObject_name_getset }
,
    { (char *) "data", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"\n"
		"The :class:`SDObjectData` with the contents of this object.\n"
		"\n"
		":type: SDObjectData\n"
		"\n"
		"", (void *) &SDObject_data_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SDObject.__dict__", (void *) &SDObject___dict___getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"\n"
		"The :class:`SDType` of this object.\n"
		"\n"
		":type: SDType\n"
		"\n"
		"", (void *) &SDObject_type_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SDObject_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SDObject_methods[] = {
  { "Duplicate", (PyCFunction) _wrap_SDObject_Duplicate, METH_NOARGS, (char *) "\n"
		"Duplicate()\n"
		"\n"
		"\n"
		":return: A new deep copy of this object, which the caller owns.\n"
		":rtype: SDObject\n"
		"\n"
		"" },
  { "HasEqualValue", (PyCFunction) _wrap_SDObject_HasEqualValue, METH_O, (char *) "\n"
		"HasEqualValue(obj)\n"
		"\n"
		"Checks if the given object has the same value as this one. This equality is defined\n"
		"recursively through children.\n"
		"\n"
		":param SDObject obj: The object to compare against\n"
		":return: A boolean indicating if the object is equal to this one.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "AddChild", (PyCFunction) _wrap_SDObject_AddChild, METH_O, (char *) "\n"
		"AddChild(child)\n"
		"\n"
		"Add a new child object.\n"
		"\n"
		":param SDObject child: The new child to add\n"
		"\n"
		"" },
  { "FindChild", (PyCFunction) _wrap_SDObject_FindChild, METH_O, (char *) "\n"
		"FindChild(childName)\n"
		"\n"
		"Find a child object by a given name. If no matching child is found, ``None`` is\n"
		"returned.\n"
		"\n"
		":param str childName: The name to search for.\n"
		":return: A reference to the child object if found, or ``None`` if not.\n"
		":rtype: SDObject\n"
		"\n"
		"" },
  { "FindChildRecursively", (PyCFunction) _wrap_SDObject_FindChildRecursively, METH_O, (char *) "\n"
		"FindChildRecursively(childName)\n"
		"\n"
		"Find a child object by a given name recursively. If no matching child is found,\n"
		"``None`` is returned.\n"
		"\n"
		"The order of the search is not guaranteed, so care should be taken when the name may not be unique.\n"
		"\n"
		":param str childName: The name to search for.\n"
		":return: A reference to the child object if found, or ``None`` if not.\n"
		":rtype: SDObject\n"
		"\n"
		"" },
  { "CreateChildByKeyPath", (PyCFunction) _wrap_SDObject_CreateChildByKeyPath, METH_O, (char *) "\n"
		"CreateChildByKeyPath(keyPath)\n"
		"\n"
		"Create a child object by a key path. Children will be created as necessary to ensure\n"
		"that the key path exists, but if they already exist then the existing object will be returned.\n"
		"\n"
		"Key paths are dotted recursive references, e.g. ``foo.bar`` is the member ``bar`` in parent ``foo``.\n"
		"\n"
		"Arrays are represented by simple numeric entries e.g. ``foo.0.bar``, ``foo.1.bar``.\n"
		"\n"
		"Empty entries are ignored so ``foo..bar`` and ``foo.bar`` refer to the same object.\n"
		"\n"
		"Key paths must not be empty and must not begin with a dot.\n"
		"\n"
		"If any path element is not unique in any child the behaviour is undefined, so objects should only be\n"
		"manipulated by key path exclusively or not at all.\n"
		"\n"
		":param str keyPath: The key path to search for and return.\n"
		":return: A reference to the object at the relative key path\n"
		":rtype: SDObject\n"
		"\n"
		"" },
  { "FindChildByKeyPath", (PyCFunction) _wrap_SDObject_FindChildByKeyPath, METH_O, (char *) "\n"
		"FindChildByKeyPath(keyPath)\n"
		"\n"
		"Find if a child object if it exists by a key path. Children will not be created\n"
		"if any element of the path doesn't exist and instead ``None`` will be returned.\n"
		"\n"
		"Key paths are dotted recursive references, e.g. ``foo.bar`` is the member ``bar`` in parent ``foo``.\n"
		"\n"
		"Arrays are represented by simple numeric entries e.g. ``foo.0.bar``, ``foo.1.bar``.\n"
		"\n"
		"Empty entries are ignored so ``foo..bar`` and ``foo.bar`` refer to the same object.\n"
		"\n"
		"Key paths must not be empty and must not begin with a dot.\n"
		"\n"
		"If any path element is not unique in any child the behaviour is undefined, so objects should only be\n"
		"manipulated by key path exclusively or not at all.\n"
		"\n"
		":param str keyPath: The key path to search for and return.\n"
		":return: Whether or not a child exists at the given key path\n"
		":rtype: SDObject\n"
		"\n"
		"" },
  { "EraseChildByKeyPath", (PyCFunction) _wrap_SDObject_EraseChildByKeyPath, METH_O, (char *) "\n"
		"EraseChildByKeyPath(keyPath)\n"
		"\n"
		"Delete a child object by a key path. All children of the resulting path will be deleted\n"
		"as well. If no such path exists, nothing will be changed.\n"
		"\n"
		"If any path element is not unique in any child the behaviour is undefined, so objects should only be\n"
		"manipulated by key path exclusively or not at all.\n"
		"\n"
		":param str keyPath: The key path to search for and delete.\n"
		"\n"
		"" },
  { "GetChild", (PyCFunction) _wrap_SDObject_GetChild, METH_O, (char *) "\n"
		"GetChild(index)\n"
		"\n"
		"Find a child object by a given index. If the index is out of bounds, ``None`` is\n"
		"returned.\n"
		"\n"
		":param int index: The index to look up.\n"
		":return: A reference to the child object if valid, or ``None`` if not.\n"
		":rtype: SDObject\n"
		"\n"
		"" },
  { "GetParent", (PyCFunction) _wrap_SDObject_GetParent, METH_NOARGS, (char *) "\n"
		"GetParent()\n"
		"\n"
		"Get the parent of this object. If this object has no parent, ``None`` is returned.\n"
		"\n"
		":return: A reference to the parent object if valid, or ``None`` if not.\n"
		":rtype: SDObject\n"
		"\n"
		"" },
  { "RemoveChild", (PyCFunction) _wrap_SDObject_RemoveChild, METH_O, (char *) "\n"
		"RemoveChild(index)\n"
		"\n"
		"Delete the child object at an index. If the index is out of bounds, nothing happens.\n"
		"\n"
		":param int index: The index to remove.\n"
		"\n"
		"" },
  { "DeleteChildren", (PyCFunction) _wrap_SDObject_DeleteChildren, METH_NOARGS, (char *) "\n"
		"DeleteChildren()\n"
		"\n"
		"Delete all child objects.\n"
		"" },
  { "NumChildren", (PyCFunction) _wrap_SDObject_NumChildren, METH_NOARGS, (char *) "\n"
		"NumChildren()\n"
		"\n"
		"Get the number of child objects.\n"
		"\n"
		":return: The number of children this object contains.\n"
		":rtype: int\n"
		"\n"
		"" },
  { "AsBool", (PyCFunction) _wrap_SDObject_AsBool, METH_NOARGS, (char *) "\n"
		"AsBool()\n"
		"\n"
		"Interprets the object as a ``bool`` and returns its value.\n"
		"Invalid if the object is not actually a ``bool``.\n"
		"\n"
		":return: The interpreted bool value.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "AsResourceId", (PyCFunction) _wrap_SDObject_AsResourceId, METH_NOARGS, (char *) "\n"
		"AsResourceId()\n"
		"\n"
		"Interprets the object as a :class:`ResourceId` and returns its value.\n"
		"Invalid if the object is not actually a :class:`ResourceId`.\n"
		"\n"
		":return: The interpreted ID.\n"
		":rtype: ResourceId\n"
		"\n"
		"" },
  { "AsInt", (PyCFunction) _wrap_SDObject_AsInt, METH_NOARGS, (char *) "\n"
		"AsInt()\n"
		"\n"
		"Interprets the object as an integer and returns its value.\n"
		"Invalid if the object is not actually an integer.\n"
		"\n"
		":return: The interpreted integer.\n"
		":rtype: int\n"
		"\n"
		"" },
  { "AsFloat", (PyCFunction) _wrap_SDObject_AsFloat, METH_NOARGS, (char *) "\n"
		"AsFloat()\n"
		"\n"
		"Interprets the object as a floating point number and returns its value.\n"
		"Invalid if the object is not actually a floating point number.\n"
		"\n"
		":return: The interpreted float.\n"
		":rtype: float\n"
		"\n"
		"" },
  { "AsString", (PyCFunction) _wrap_SDObject_AsString, METH_NOARGS, (char *) "\n"
		"AsString()\n"
		"\n"
		"Interprets the object as a string and returns its value.\n"
		"Invalid if the object is not actually a string.\n"
		"\n"
		":return: The interpreted string.\n"
		":rtype: str\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SDObject_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.SDObject",                     /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SDObject_dealloc_destructor_closure,             /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SDObject_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__SDObject_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__SDObject_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SDObject_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Defines a single structured object. Structured objects are defined recursively and one\n"
		"object can either be a basic type (integer, float, etc), an array, or a struct. Arrays and structs\n"
		"are defined similarly.\n"
		"\n"
		"Each object owns its children and they will be deleted when it is deleted. You can use\n"
		":meth:`Duplicate` to make a deep copy of an object.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SDObject_richcompare,            /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SDObject_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SDObject_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SDObject_init,                 /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SDObject_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SDObject_type};

static SwigPyGetSet SDChunk___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet SDChunk_metadata_getset = { _wrap_SDChunk_metadata_get, _wrap_SDChunk_metadata_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SDChunk_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SDChunk.__dict__", (void *) &SDChunk___dict___getset }
,
    { (char *) "metadata", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`SDChunkMetaData` with the metadata for this chunk.\n"
		"\n"
		":type: SDChunkMetaData\n"
		"\n"
		"", (void *) &SDChunk_metadata_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SDChunk_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SDChunk_methods[] = {
  { "Duplicate", (PyCFunction) _wrap_SDChunk_Duplicate, METH_NOARGS, (char *) "\n"
		"Duplicate()\n"
		"\n"
		"\n"
		":return: A new deep copy of this chunk, which the caller owns.\n"
		":rtype: SDChunk\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SDChunk_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.SDChunk",                      /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SDChunk_dealloc_destructor_closure,              /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SDChunk_type.as_number,   /* tp_as_number */
    &SwigPyBuiltin__SDChunk_type.as_sequence, /* tp_as_sequence */
    &SwigPyBuiltin__SDChunk_type.as_mapping,  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SDChunk_type.as_buffer,   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Defines a single structured chunk, which is a :class:`SDObject`.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SDChunk_richcompare,             /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SDChunk_methods,           /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SDChunk_getset,            /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SDChunk_init,                  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SDChunk_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SDChunk_type};

static SwigPyGetSet StructuredChunkList___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__StructuredChunkList_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"StructuredChunkList.__dict__", (void *) &StructuredChunkList___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__StructuredChunkList_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__StructuredChunkList_methods[] = {
  { "append", (PyCFunction) _wrap_StructuredChunkList_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_StructuredChunkList_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_StructuredChunkList_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_StructuredChunkList_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_StructuredChunkList_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_StructuredChunkList_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_StructuredChunkList_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_StructuredChunkList_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_StructuredChunkList_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_StructuredChunkList_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_StructuredChunkList_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__StructuredChunkList_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.StructuredChunkList",          /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_StructuredChunkList,      /* tp_repr */
    &SwigPyBuiltin__StructuredChunkList_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__StructuredChunkList_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__StructuredChunkList_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_StructuredChunkList,      /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__StructuredChunkList_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "INTERNAL: An array of SDChunk*, mapped to a pure list in python",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__StructuredChunkList_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__StructuredChunkList_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__StructuredChunkList_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_StructuredChunkList,                /* mp_subscript */
    (objobjargproc) setsubscript_StructuredChunkList,             /* mp_ass_subscript */
  },
  {
    (lenfunc) length_StructuredChunkList,     /* sq_length */
    (binaryfunc) concat_StructuredChunkList,  /* sq_concat */
    (ssizeargfunc) repeat_StructuredChunkList,/* sq_repeat */
    (ssizeargfunc) getitem_StructuredChunkList,                   /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_StructuredChunkList,                /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_StructuredChunkList,                  /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_StructuredChunkList,                /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__StructuredChunkList_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__StructuredChunkList_type};

static SwigPyGetSet StructuredBufferList___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__StructuredBufferList_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"StructuredBufferList.__dict__", (void *) &StructuredBufferList___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__StructuredBufferList_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__StructuredBufferList_methods[] = {
  { "append", (PyCFunction) _wrap_StructuredBufferList_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_StructuredBufferList_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_StructuredBufferList_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_StructuredBufferList_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_StructuredBufferList_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_StructuredBufferList_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_StructuredBufferList_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_StructuredBufferList_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_StructuredBufferList_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_StructuredBufferList_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_StructuredBufferList_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__StructuredBufferList_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.StructuredBufferList",         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SwigPyBuiltin_BadDealloc,    /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_StructuredBufferList,     /* tp_repr */
    &SwigPyBuiltin__StructuredBufferList_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__StructuredBufferList_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__StructuredBufferList_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_StructuredBufferList,     /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__StructuredBufferList_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "INTERNAL: An array of bytebuf*, mapped to a pure list of bytes in python",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__StructuredBufferList_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__StructuredBufferList_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__StructuredBufferList_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_StructuredBufferList,               /* mp_subscript */
    (objobjargproc) setsubscript_StructuredBufferList,            /* mp_ass_subscript */
  },
  {
    (lenfunc) length_StructuredBufferList,    /* sq_length */
    (binaryfunc) concat_StructuredBufferList, /* sq_concat */
    (ssizeargfunc) repeat_StructuredBufferList,                   /* sq_repeat */
    (ssizeargfunc) getitem_StructuredBufferList,                  /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_StructuredBufferList,               /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_StructuredBufferList,                 /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_StructuredBufferList,               /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__StructuredBufferList_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__StructuredBufferList_type};

static SwigPyGetSet SDFile_chunks_getset = { _wrap_SDFile_chunks_get, _wrap_SDFile_chunks_set };
static SwigPyGetSet SDFile___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet SDFile_version_getset = { _wrap_SDFile_version_get, _wrap_SDFile_version_set };
static SwigPyGetSet SDFile_buffers_getset = { _wrap_SDFile_buffers_get, _wrap_SDFile_buffers_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SDFile_getset[] = {
    { (char *) "chunks", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The chunks in the file in order.\n"
		"\n"
		":type: List[SDChunk]\n"
		"\n"
		"", (void *) &SDFile_chunks_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SDFile.__dict__", (void *) &SDFile___dict___getset }
,
    { (char *) "version", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The version of this structured stream, typically only used internally.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SDFile_version_getset }
,
    { (char *) "buffers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The buffers in the file, as referenced by the chunks in :data:`chunks`.\n"
		"\n"
		":type: List[bytes]\n"
		"\n"
		"", (void *) &SDFile_buffers_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SDFile_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SDFile_methods[] = {
  { "Swap", (PyCFunction) _wrap_SDFile_Swap, METH_O, (char *) "\n"
		"Swap(other)\n"
		"\n"
		"Swaps the contents of this file with another.\n"
		"\n"
		":param SDFile other: The other file to swap with.\n"
		"\n"
		"" },
  { "Detach", (PyCFunction) _wrap_SDFile_Detach, METH_NOARGS, (char *) "\n"
		"Detach()\n"
		"\n"
		"Prepares the SDFile to remove any possible dependencies on what\n"
		"created it.\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SDFile_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.SDFile",                       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) SDFile_dealloc_destructor_closure,               /* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SDFile_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__SDFile_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__SDFile_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SDFile_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the structured information in a file. Owns the buffers and chunks.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SDFile_richcompare,              /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SDFile_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SDFile_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SDFile_init,                   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SDFile_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SDFile_type};

static SwigPyGetSet CaptureOptions_verifyBufferAccess_getset = { _wrap_CaptureOptions_verifyBufferAccess_get, _wrap_CaptureOptions_verifyBufferAccess_set };
static SwigPyGetSet CaptureOptions_allowVSync_getset = { _wrap_CaptureOptions_allowVSync_get, _wrap_CaptureOptions_allowVSync_set };
static SwigPyGetSet CaptureOptions_captureCallstacksOnlyActions_getset = { _wrap_CaptureOptions_captureCallstacksOnlyActions_get, _wrap_CaptureOptions_captureCallstacksOnlyActions_set };
static SwigPyGetSet CaptureOptions_captureAllCmdLists_getset = { _wrap_CaptureOptions_captureAllCmdLists_get, _wrap_CaptureOptions_captureAllCmdLists_set };
static SwigPyGetSet CaptureOptions___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet CaptureOptions_apiValidation_getset = { _wrap_CaptureOptions_apiValidation_get, _wrap_CaptureOptions_apiValidation_set };
static SwigPyGetSet CaptureOptions_softMemoryLimit_getset = { _wrap_CaptureOptions_softMemoryLimit_get, _wrap_CaptureOptions_softMemoryLimit_set };
static SwigPyGetSet CaptureOptions_captureCallstacks_getset = { _wrap_CaptureOptions_captureCallstacks_get, _wrap_CaptureOptions_captureCallstacks_set };
static SwigPyGetSet CaptureOptions_delayForDebugger_getset = { _wrap_CaptureOptions_delayForDebugger_get, _wrap_CaptureOptions_delayForDebugger_set };
static SwigPyGetSet CaptureOptions_debugOutputMute_getset = { _wrap_CaptureOptions_debugOutputMute_get, _wrap_CaptureOptions_debugOutputMute_set };
static SwigPyGetSet CaptureOptions_allowFullscreen_getset = { _wrap_CaptureOptions_allowFullscreen_get, _wrap_CaptureOptions_allowFullscreen_set };
static SwigPyGetSet CaptureOptions_hookIntoChildren_getset = { _wrap_CaptureOptions_hookIntoChildren_get, _wrap_CaptureOptions_hookIntoChildren_set };
static SwigPyGetSet CaptureOptions_refAllResources_getset = { _wrap_CaptureOptions_refAllResources_get, _wrap_CaptureOptions_refAllResources_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CaptureOptions_getset[] = {
    { (char *) "verifyBufferAccess", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Verify buffer access. This includes checking the memory returned by a Map() call to\n"
		"detect any out-of-bounds modification, as well as initialising buffers with undefined contents to\n"
		"a marker value to catch use of uninitialised memory.\n"
		"\n"
		".. note::\n"
		"\n"
		"  This option is only valid for OpenGL and D3D11. Explicit APIs such as D3D12 and Vulkan do not\n"
		"  do the same kind of interception & checking and undefined contents are really undefined.\n"
		"\n"
		"Default - disabled\n"
		"\n"
		"``True`` - Verify buffer access.\n"
		"\n"
		"``False`` - No verification is performed, and overwriting bounds may cause crashes or corruption in\n"
		"RenderDoc.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &CaptureOptions_verifyBufferAccess_getset }
,
    { (char *) "allowVSync", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Allow the application to enable vsync.\n"
		"\n"
		"Default - enabled\n"
		"\n"
		"``True`` - The application can enable or disable vsync at will.\n"
		"\n"
		"``False`` - vsync is force disabled.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &CaptureOptions_allowVSync_getset }
,
    { (char *) "captureCallstacksOnlyActions", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"When capturing CPU callstacks, only capture them from actions.\n"
		"This option does nothing if :data:`captureCallstacks` is not enabled.\n"
		"\n"
		"Default - disabled\n"
		"\n"
		"``True`` - Only captures callstacks for actions.\n"
		"\n"
		"``False`` - Callstacks, if enabled, are captured for every event.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &CaptureOptions_captureCallstacksOnlyActions_getset }
,
    { (char *) "captureAllCmdLists", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"In APIs that allow for the recording of command lists to be replayed later,\n"
		"RenderDoc may choose to not capture command lists before a frame capture is\n"
		"triggered, to reduce overheads. This means any command lists recorded once\n"
		"and replayed many times will not be available and may cause a failure to\n"
		"capture.\n"
		"\n"
		".. note:: This is only true for APIs where multithreading is difficult or\n"
		"  discouraged. Newer APIs like Vulkan and D3D12 will ignore this option\n"
		"  and always capture all command lists since the API is heavily oriented\n"
		"  around it and the overheads have been reduced by API design.\n"
		"\n"
		"``True`` - All command lists are captured from the start of the application.\n"
		"\n"
		"``False`` - Command lists are only captured if their recording begins during\n"
		"the period when a frame capture is in progress.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &CaptureOptions_captureAllCmdLists_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"CaptureOptions.__dict__", (void *) &CaptureOptions___dict___getset }
,
    { (char *) "apiValidation", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Record API debugging events and messages\n"
		"\n"
		"Default - disabled\n"
		"\n"
		"``True`` - Enable built-in API debugging features and records the results into\n"
		"the capture logfile, which is matched up with events on replay.\n"
		"\n"
		"``False`` - no API debugging is forcibly enabled.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &CaptureOptions_apiValidation_getset }
,
    { (char *) "softMemoryLimit", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Define a soft memory limit which some APIs may aim to keep overhead under where\n"
		"possible. Anything above this limit will where possible be saved directly to disk during capture.\n"
		"This will cause increased disk space use (which may cause a capture to fail if disk space is\n"
		"exhausted) as well as slower capture times.\n"
		"\n"
		"Not all memory allocations may be deferred like this so it is not a guarantee of a memory limit.\n"
		"\n"
		"Units are in MBs, suggested values would range from 200MB to 1000MB.\n"
		"\n"
		"Default - 0 Megabytes\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &CaptureOptions_softMemoryLimit_getset }
,
    { (char *) "captureCallstacks", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Capture CPU callstacks for API events\n"
		"\n"
		"Default - disabled\n"
		"\n"
		"``True`` - Enables capturing of callstacks.\n"
		"\n"
		"``False`` - no callstacks are captured.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &CaptureOptions_captureCallstacks_getset }
,
    { (char *) "delayForDebugger", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Specify a delay in seconds to wait for a debugger to attach, after\n"
		"creating or injecting into a process, before continuing to allow it to run.\n"
		"\n"
		"``0`` indicates no delay, and the process will run immediately after injection.\n"
		"\n"
		"Default - 0 seconds\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &CaptureOptions_delayForDebugger_getset }
,
    { (char *) "debugOutputMute", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Mute API debugging output when the API validation mode option is enabled.\n"
		"\n"
		"Default - enabled\n"
		"\n"
		"``True`` - Mute any API debug messages from being displayed or passed through.\n"
		"\n"
		"``False`` - API debugging is displayed as normal.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &CaptureOptions_debugOutputMute_getset }
,
    { (char *) "allowFullscreen", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Allow the application to enable fullscreen.\n"
		"\n"
		"Default - enabled\n"
		"\n"
		"``True`` - The application can enable or disable fullscreen at will.\n"
		"\n"
		"``False`` - fullscreen is force disabled.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &CaptureOptions_allowFullscreen_getset }
,
    { (char *) "hookIntoChildren", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Hooks any system API calls that create child processes, and injects\n"
		"RenderDoc into them recursively with the same options.\n"
		"\n"
		"Default - disabled\n"
		"\n"
		"``True`` - Hooks into spawned child processes.\n"
		"\n"
		"``False`` - Child processes are not hooked by RenderDoc.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &CaptureOptions_hookIntoChildren_getset }
,
    { (char *) "refAllResources", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"By default RenderDoc only includes resources in the final logfile necessary\n"
		"for that frame, this allows you to override that behaviour.\n"
		"\n"
		"Default - disabled\n"
		"\n"
		"``True`` - all live resources at the time of capture are included in the log\n"
		"and available for inspection.\n"
		"\n"
		"``False`` - only the resources referenced by the captured frame are included.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &CaptureOptions_refAllResources_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__CaptureOptions_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__CaptureOptions_methods[] = {
  { "EncodeAsString", (PyCFunction) _wrap_CaptureOptions_EncodeAsString, METH_NOARGS, (char *) "\n"
		"EncodeAsString()\n"
		"\n"
		"Encode the current options to a string suitable for passing around between processes.\n"
		"\n"
		":return: The encoded string, suitable for passing to :meth:`DecodeFromString`.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "DecodeFromString", (PyCFunction) _wrap_CaptureOptions_DecodeFromString, METH_O, (char *) "\n"
		"DecodeFromString(encoded)\n"
		"\n"
		"Decode the options from a string, as returned by :meth:`EncodeAsString`. Updates this\n"
		"object in place.\n"
		"\n"
		":param str encoded: The encoded string, as returned by :meth:`EncodeAsString`.\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__CaptureOptions_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.CaptureOptions",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_CaptureOptions_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__CaptureOptions_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__CaptureOptions_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__CaptureOptions_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__CaptureOptions_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Sets up configuration and options for optional features either at capture time or at API\n"
		"initialisation time that the user can enable or disable at will.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__CaptureOptions_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__CaptureOptions_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__CaptureOptions_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_CaptureOptions,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__CaptureOptions_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CaptureOptions_type};

static SwigPyGetSet TaskGroupSize_x_getset = { _wrap_TaskGroupSize_x_get, _wrap_TaskGroupSize_x_set };
static SwigPyGetSet TaskGroupSize___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet TaskGroupSize_y_getset = { _wrap_TaskGroupSize_y_get, _wrap_TaskGroupSize_y_set };
static SwigPyGetSet TaskGroupSize_z_getset = { _wrap_TaskGroupSize_z_get, _wrap_TaskGroupSize_z_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TaskGroupSize_getset[] = {
    { (char *) "x", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size in the x dimension.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TaskGroupSize_x_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TaskGroupSize.__dict__", (void *) &TaskGroupSize___dict___getset }
,
    { (char *) "y", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size in the y dimension.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TaskGroupSize_y_getset }
,
    { (char *) "z", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size in the z dimension.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TaskGroupSize_z_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TaskGroupSize_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_TaskGroupSize___eq__(self, other); break;
    case Py_LT : result = _wrap_TaskGroupSize___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TaskGroupSize_methods[] = {
  { "__eq__", (PyCFunction) _wrap_TaskGroupSize___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_TaskGroupSize___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TaskGroupSize_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.TaskGroupSize",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TaskGroupSize_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TaskGroupSize_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__TaskGroupSize_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__TaskGroupSize_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TaskGroupSize_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The size information for a task group.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TaskGroupSize_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TaskGroupSize_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TaskGroupSize_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TaskGroupSize,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TaskGroupSize_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TaskGroupSize_type};

static SwigPyGetSet MeshletSize___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet MeshletSize_numIndices_getset = { _wrap_MeshletSize_numIndices_get, _wrap_MeshletSize_numIndices_set };
static SwigPyGetSet MeshletSize_numVertices_getset = { _wrap_MeshletSize_numVertices_get, _wrap_MeshletSize_numVertices_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__MeshletSize_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"MeshletSize.__dict__", (void *) &MeshletSize___dict___getset }
,
    { (char *) "numIndices", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of indices in the meshlet.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshletSize_numIndices_getset }
,
    { (char *) "numVertices", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of vertices in this meshlet. This may be larger or smaller than the number\n"
		"of indices.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshletSize_numVertices_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__MeshletSize_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_MeshletSize___eq__(self, other); break;
    case Py_LT : result = _wrap_MeshletSize___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__MeshletSize_methods[] = {
  { "__eq__", (PyCFunction) _wrap_MeshletSize___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_MeshletSize___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__MeshletSize_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.MeshletSize",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_MeshletSize_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__MeshletSize_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__MeshletSize_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__MeshletSize_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__MeshletSize_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The size information for a meshlet.\n"
		"\n"
		"",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__MeshletSize_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__MeshletSize_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__MeshletSize_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_MeshletSize,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__MeshletSize_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__MeshletSize_type};

static SwigPyGetSet MeshFormat_instanced_getset = { _wrap_MeshFormat_instanced_get, _wrap_MeshFormat_instanced_set };
static SwigPyGetSet MeshFormat_dispatchSize_getset = { _wrap_MeshFormat_dispatchSize_get, _wrap_MeshFormat_dispatchSize_set };
static SwigPyGetSet MeshFormat_baseVertex_getset = { _wrap_MeshFormat_baseVertex_get, _wrap_MeshFormat_baseVertex_set };
static SwigPyGetSet MeshFormat_vertexResourceId_getset = { _wrap_MeshFormat_vertexResourceId_get, _wrap_MeshFormat_vertexResourceId_set };
static SwigPyGetSet MeshFormat_indexResourceId_getset = { _wrap_MeshFormat_indexResourceId_get, _wrap_MeshFormat_indexResourceId_set };
static SwigPyGetSet MeshFormat_allowRestart_getset = { _wrap_MeshFormat_allowRestart_get, _wrap_MeshFormat_allowRestart_set };
static SwigPyGetSet MeshFormat_instStepRate_getset = { _wrap_MeshFormat_instStepRate_get, _wrap_MeshFormat_instStepRate_set };
static SwigPyGetSet MeshFormat_format_getset = { _wrap_MeshFormat_format_get, _wrap_MeshFormat_format_set };
static SwigPyGetSet MeshFormat_vertexByteStride_getset = { _wrap_MeshFormat_vertexByteStride_get, _wrap_MeshFormat_vertexByteStride_set };
static SwigPyGetSet MeshFormat_indexByteStride_getset = { _wrap_MeshFormat_indexByteStride_get, _wrap_MeshFormat_indexByteStride_set };
static SwigPyGetSet MeshFormat___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet MeshFormat_perPrimitiveStride_getset = { _wrap_MeshFormat_perPrimitiveStride_get, _wrap_MeshFormat_perPrimitiveStride_set };
static SwigPyGetSet MeshFormat_nearPlane_getset = { _wrap_MeshFormat_nearPlane_get, _wrap_MeshFormat_nearPlane_set };
static SwigPyGetSet MeshFormat_farPlane_getset = { _wrap_MeshFormat_farPlane_get, _wrap_MeshFormat_farPlane_set };
static SwigPyGetSet MeshFormat_unproject_getset = { _wrap_MeshFormat_unproject_get, _wrap_MeshFormat_unproject_set };
static SwigPyGetSet MeshFormat_vertexByteOffset_getset = { _wrap_MeshFormat_vertexByteOffset_get, _wrap_MeshFormat_vertexByteOffset_set };
static SwigPyGetSet MeshFormat_indexByteOffset_getset = { _wrap_MeshFormat_indexByteOffset_get, _wrap_MeshFormat_indexByteOffset_set };
static SwigPyGetSet MeshFormat_perPrimitiveOffset_getset = { _wrap_MeshFormat_perPrimitiveOffset_get, _wrap_MeshFormat_perPrimitiveOffset_set };
static SwigPyGetSet MeshFormat_numIndices_getset = { _wrap_MeshFormat_numIndices_get, _wrap_MeshFormat_numIndices_set };
static SwigPyGetSet MeshFormat_taskSizes_getset = { _wrap_MeshFormat_taskSizes_get, _wrap_MeshFormat_taskSizes_set };
static SwigPyGetSet MeshFormat_vertexByteSize_getset = { _wrap_MeshFormat_vertexByteSize_get, _wrap_MeshFormat_vertexByteSize_set };
static SwigPyGetSet MeshFormat_indexByteSize_getset = { _wrap_MeshFormat_indexByteSize_get, _wrap_MeshFormat_indexByteSize_set };
static SwigPyGetSet MeshFormat_meshletSizes_getset = { _wrap_MeshFormat_meshletSizes_get, _wrap_MeshFormat_meshletSizes_set };
static SwigPyGetSet MeshFormat_topology_getset = { _wrap_MeshFormat_topology_get, _wrap_MeshFormat_topology_set };
static SwigPyGetSet MeshFormat_meshletOffset_getset = { _wrap_MeshFormat_meshletOffset_get, _wrap_MeshFormat_meshletOffset_set };
static SwigPyGetSet MeshFormat_meshletIndexOffset_getset = { _wrap_MeshFormat_meshletIndexOffset_get, _wrap_MeshFormat_meshletIndexOffset_set };
static SwigPyGetSet MeshFormat_restartIndex_getset = { _wrap_MeshFormat_restartIndex_get, _wrap_MeshFormat_restartIndex_set };
static SwigPyGetSet MeshFormat_meshColor_getset = { _wrap_MeshFormat_meshColor_get, _wrap_MeshFormat_meshColor_set };
static SwigPyGetSet MeshFormat_status_getset = { _wrap_MeshFormat_status_get, _wrap_MeshFormat_status_set };
static SwigPyGetSet MeshFormat_showAlpha_getset = { _wrap_MeshFormat_showAlpha_get, _wrap_MeshFormat_showAlpha_set };
static SwigPyGetSet MeshFormat_flipY_getset = { _wrap_MeshFormat_flipY_get, _wrap_MeshFormat_flipY_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__MeshFormat_getset[] = {
    { (char *) "instanced", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this mesh element comes from instanced data. See :data:`instStepRate`.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &MeshFormat_instanced_getset }
,
    { (char *) "dispatchSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size of the dispatch that launched a meshlet based draw.\n"
		"\n"
		"Only valid for the task stage if task shaders are used.\n"
		"\n"
		".. note::\n"
		"  This is present because the dispatch size at the time of the mesh output fetch may not match the\n"
		"  :data:`ActionDescription.dispatchDimension` due to non-determinism in the capture. Being present\n"
		"  here allows the replay to process the mesh output validly in itself without seeing a mismatch.\n"
		"\n"
		":type: Tuple[int,int,int]\n"
		"\n"
		"", (void *) &MeshFormat_dispatchSize_getset }
,
    { (char *) "baseVertex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For indexed meshes, a value added to each index before using it to read the vertex.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_baseVertex_getset }
,
    { (char *) "vertexResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the vertex buffer containing this mesh element.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &MeshFormat_vertexResourceId_getset }
,
    { (char *) "indexResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the index buffer that goes with this mesh element.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &MeshFormat_indexResourceId_getset }
,
    { (char *) "allowRestart", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the primitive restart index feature should be used.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &MeshFormat_allowRestart_getset }
,
    { (char *) "instStepRate", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of instances to render with the same value. See :data:`instanced`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_instStepRate_getset }
,
    { (char *) "format", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The format description of this mesh components elements.\n"
		"\n"
		":type: ResourceFormat\n"
		"\n"
		"", (void *) &MeshFormat_format_getset }
,
    { (char *) "vertexByteStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stride in bytes between the start of one vertex and the start of another.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_vertexByteStride_getset }
,
    { (char *) "indexByteStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The width in bytes of each index. Valid values are 1 (depending on API), 2 or 4.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_indexByteStride_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"MeshFormat.__dict__", (void *) &MeshFormat___dict___getset }
,
    { (char *) "perPrimitiveStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stride in bytes of the per-primitive rate vertex data.\n"
		"\n"
		"Only for meshlet outputs.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_perPrimitiveStride_getset }
,
    { (char *) "nearPlane", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The near plane for the projection matrix.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &MeshFormat_nearPlane_getset }
,
    { (char *) "farPlane", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The far plane for the projection matrix.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &MeshFormat_farPlane_getset }
,
    { (char *) "unproject", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this mesh element contains post-projection positional data.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &MeshFormat_unproject_getset }
,
    { (char *) "vertexByteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in bytes to the start of the vertex data.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_vertexByteOffset_getset }
,
    { (char *) "indexByteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in bytes where the indices start in idxbuf.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_indexByteOffset_getset }
,
    { (char *) "perPrimitiveOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in bytes to the start of the per-primitive rate vertex data.\n"
		"\n"
		"Only for meshlet outputs.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_perPrimitiveOffset_getset }
,
    { (char *) "numIndices", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of vertices in the mesh.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_numIndices_getset }
,
    { (char *) "taskSizes", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size of each task group's dispatch, for a meshlet based draw.\n"
		"\n"
		"Each group of a task shader within a dispatch can itself fill out a payload and dispatch a number\n"
		"of mesh groups. This list contains the 3-dimensional dimension that each task group emitted.\n"
		"\n"
		":type: List[TaskGroupSize]\n"
		"\n"
		"", (void *) &MeshFormat_taskSizes_getset }
,
    { (char *) "vertexByteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of bytes to use from the vertex buffer. Only valid on APIs that allow it.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_vertexByteSize_getset }
,
    { (char *) "indexByteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of bytes to use from the index buffer. Only valid on APIs that allow it.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_indexByteSize_getset }
,
    { (char *) "meshletSizes", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size of each meshlet, for a meshlet based draw.\n"
		"\n"
		"Each meshlet lists its individual size, but a cumulative sum can be used for defining boundaries\n"
		"between meshlets either by raw vertex order (using the number of indices) or by index value (using\n"
		"the number of vertices).\n"
		"\n"
		":type: List[MeshletSize]\n"
		"\n"
		"", (void *) &MeshFormat_meshletSizes_getset }
,
    { (char *) "topology", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`Topology` that describes the primitives in this mesh.\n"
		"\n"
		":type: Topology\n"
		"\n"
		"", (void *) &MeshFormat_topology_getset }
,
    { (char *) "meshletOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If showing a set of meshlets that don't start from meshlet 0, this is the number of\n"
		"meshlet to consider skipped before :data:`meshletSizes`.\n"
		"\n"
		"Primarily useful for keeping a consistent colouring of meshlets when filtering to a subset\n"
		"\n"
		"See also :data:`meshletIndexOffset`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_meshletOffset_getset }
,
    { (char *) "meshletIndexOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If showing a set of meshlets that don't start from index 0, this is the number of\n"
		"vertices to consider skipped before :data:`meshletSizes` - equivalent to baseVertex.\n"
		"\n"
		"Primarily useful for keeping a consistent colouring of meshlets when filtering to a subset\n"
		"\n"
		"See also :data:`meshletOffset`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_meshletIndexOffset_getset }
,
    { (char *) "restartIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The primitive restart index to use, if possible. See :data:`allowRestart`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshFormat_restartIndex_getset }
,
    { (char *) "meshColor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The color to use for rendering the wireframe of this mesh element.\n"
		"\n"
		":type: FloatVector\n"
		"\n"
		"", (void *) &MeshFormat_meshColor_getset }
,
    { (char *) "status", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A string with the status of this mesh format - only used when a mesh format is\n"
		"returned to the application detailing e.g. vertex output data.\n"
		"\n"
		"An empty string indicates no errors/problems.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &MeshFormat_status_getset }
,
    { (char *) "showAlpha", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the alpha component of this element should be used.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &MeshFormat_showAlpha_getset }
,
    { (char *) "flipY", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if there is an implicit Y-flip to account for in the projection.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &MeshFormat_flipY_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__MeshFormat_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__MeshFormat_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__MeshFormat_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.MeshFormat",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_MeshFormat_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__MeshFormat_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__MeshFormat_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__MeshFormat_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__MeshFormat_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Contains the details of a single element of data (such as position or texture\n"
		"co-ordinates) within a mesh.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__MeshFormat_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__MeshFormat_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__MeshFormat_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_MeshFormat,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__MeshFormat_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__MeshFormat_type};

static SwigPyGetSet MeshDisplay_showBBox_getset = { _wrap_MeshDisplay_showBBox_get, _wrap_MeshDisplay_showBBox_set };
static SwigPyGetSet MeshDisplay_wireframeDraw_getset = { _wrap_MeshDisplay_wireframeDraw_get, _wrap_MeshDisplay_wireframeDraw_set };
static SwigPyGetSet MeshDisplay_showPrevInstances_getset = { _wrap_MeshDisplay_showPrevInstances_get, _wrap_MeshDisplay_showPrevInstances_set };
static SwigPyGetSet MeshDisplay_showAllInstances_getset = { _wrap_MeshDisplay_showAllInstances_get, _wrap_MeshDisplay_showAllInstances_set };
static SwigPyGetSet MeshDisplay_curView_getset = { _wrap_MeshDisplay_curView_get, _wrap_MeshDisplay_curView_set };
static SwigPyGetSet MeshDisplay_cam_getset = { _wrap_MeshDisplay_cam_get, _wrap_MeshDisplay_cam_set };
static SwigPyGetSet MeshDisplay_aspect_getset = { _wrap_MeshDisplay_aspect_get, _wrap_MeshDisplay_aspect_set };
static SwigPyGetSet MeshDisplay_visualisationMode_getset = { _wrap_MeshDisplay_visualisationMode_get, _wrap_MeshDisplay_visualisationMode_set };
static SwigPyGetSet MeshDisplay___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet MeshDisplay_ortho_getset = { _wrap_MeshDisplay_ortho_get, _wrap_MeshDisplay_ortho_set };
static SwigPyGetSet MeshDisplay_second_getset = { _wrap_MeshDisplay_second_get, _wrap_MeshDisplay_second_set };
static SwigPyGetSet MeshDisplay_minBounds_getset = { _wrap_MeshDisplay_minBounds_get, _wrap_MeshDisplay_minBounds_set };
static SwigPyGetSet MeshDisplay_maxBounds_getset = { _wrap_MeshDisplay_maxBounds_get, _wrap_MeshDisplay_maxBounds_set };
static SwigPyGetSet MeshDisplay_position_getset = { _wrap_MeshDisplay_position_get, _wrap_MeshDisplay_position_set };
static SwigPyGetSet MeshDisplay_type_getset = { _wrap_MeshDisplay_type_get, _wrap_MeshDisplay_type_set };
static SwigPyGetSet MeshDisplay_axisMapping_getset = { _wrap_MeshDisplay_axisMapping_get, _wrap_MeshDisplay_axisMapping_set };
static SwigPyGetSet MeshDisplay_vtxExploderSliderSNorm_getset = { _wrap_MeshDisplay_vtxExploderSliderSNorm_get, _wrap_MeshDisplay_vtxExploderSliderSNorm_set };
static SwigPyGetSet MeshDisplay_curInstance_getset = { _wrap_MeshDisplay_curInstance_get, _wrap_MeshDisplay_curInstance_set };
static SwigPyGetSet MeshDisplay_exploderScale_getset = { _wrap_MeshDisplay_exploderScale_get, _wrap_MeshDisplay_exploderScale_set };
static SwigPyGetSet MeshDisplay_highlightVert_getset = { _wrap_MeshDisplay_highlightVert_get, _wrap_MeshDisplay_highlightVert_set };
static SwigPyGetSet MeshDisplay_fov_getset = { _wrap_MeshDisplay_fov_get, _wrap_MeshDisplay_fov_set };
static SwigPyGetSet MeshDisplay_showWholePass_getset = { _wrap_MeshDisplay_showWholePass_get, _wrap_MeshDisplay_showWholePass_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__MeshDisplay_getset[] = {
    { (char *) "showBBox", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the bounding box around the mesh should be rendered.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &MeshDisplay_showBBox_getset }
,
    { (char *) "wireframeDraw", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the wireframe of the mesh should be rendered as well as solid shading.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &MeshDisplay_wireframeDraw_getset }
,
    { (char *) "showPrevInstances", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if all previous instances in the drawcall should be drawn as secondary meshes.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &MeshDisplay_showPrevInstances_getset }
,
    { (char *) "showAllInstances", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if all instances in the drawcall should be drawn as secondary meshes.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &MeshDisplay_showAllInstances_getset }
,
    { (char *) "curView", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index of the currently selected multiview view in the drawcall.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshDisplay_curView_getset }
,
    { (char *) "cam", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The camera to use when rendering all of the meshes.\n"
		"\n"
		":type: Camera\n"
		"\n"
		"", (void *) &MeshDisplay_cam_getset }
,
    { (char *) "aspect", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The aspect ratio to use when calculating a perspective projection matrix.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &MeshDisplay_aspect_getset }
,
    { (char *) "visualisationMode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`visualisation mode <Visualisation>` to use when rendering the current mesh.\n"
		"\n"
		":type: Visualisation\n"
		"\n"
		"", (void *) &MeshDisplay_visualisationMode_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"MeshDisplay.__dict__", (void *) &MeshDisplay___dict___getset }
,
    { (char *) "ortho", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the projection matrix to use when unprojecting vertex positions is orthographic.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &MeshDisplay_ortho_getset }
,
    { (char *) "second", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The configuration for the primary mesh's secondary data, if used for solid shading.\n"
		"\n"
		":type: MeshFormat\n"
		"\n"
		"", (void *) &MeshDisplay_second_getset }
,
    { (char *) "minBounds", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The minimum co-ordinates in each axis of the mesh bounding box.\n"
		"\n"
		":type: FloatVector\n"
		"\n"
		"", (void *) &MeshDisplay_minBounds_getset }
,
    { (char *) "maxBounds", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The maximum co-ordinates in each axis of the mesh bounding box.\n"
		"\n"
		":type: FloatVector\n"
		"\n"
		"", (void *) &MeshDisplay_maxBounds_getset }
,
    { (char *) "position", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The configuration for the primary mesh's position data.\n"
		"\n"
		":type: MeshFormat\n"
		"\n"
		"", (void *) &MeshDisplay_position_getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`MeshDataStage` where this mesh data comes from.\n"
		"\n"
		":type: MeshDataStage\n"
		"\n"
		"", (void *) &MeshDisplay_type_getset }
,
    { (char *) "axisMapping", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The axis mapping to apply to the mesh.\n"
		"\n"
		":type: AxisMapping\n"
		"\n"
		"", (void *) &MeshDisplay_axisMapping_getset }
,
    { (char *) "vtxExploderSliderSNorm", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Displace/explode vertices to help visualise vertex reuse vs disjointedness.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &MeshDisplay_vtxExploderSliderSNorm_getset }
,
    { (char *) "curInstance", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index of the currently selected instance in the drawcall.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshDisplay_curInstance_getset }
,
    { (char *) "exploderScale", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Scales the exploded vertex displacement.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &MeshDisplay_exploderScale_getset }
,
    { (char *) "highlightVert", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index of the vertex to highlight, or :data:`NoHighlight` to select no vertex.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &MeshDisplay_highlightVert_getset }
,
    { (char *) "fov", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The field of view to use when calculating a perspective projection matrix.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &MeshDisplay_fov_getset }
,
    { (char *) "showWholePass", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if all draws in the current pass up to the current draw should be drawn as secondary meshes.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &MeshDisplay_showWholePass_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__MeshDisplay_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__MeshDisplay_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__MeshDisplay_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.MeshDisplay",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_MeshDisplay_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__MeshDisplay_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__MeshDisplay_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__MeshDisplay_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__MeshDisplay_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"\n"
		"Describes how to render a mesh preview of one or more meshes. Describes the camera configuration as\n"
		"well as what options to use when rendering both the current mesh, and any other auxilliary meshes.\n"
		"\n"
		".. data:: NoHighlight\n"
		"\n"
		"  Value for :data:`highlightVert` if no vertex should be highlighted.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__MeshDisplay_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__MeshDisplay_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__MeshDisplay_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_MeshDisplay,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__MeshDisplay_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__MeshDisplay_type};

static SwigPyGetSet TextureDisplay_backgroundColor_getset = { _wrap_TextureDisplay_backgroundColor_get, _wrap_TextureDisplay_backgroundColor_set };
static SwigPyGetSet TextureDisplay_overlay_getset = { _wrap_TextureDisplay_overlay_get, _wrap_TextureDisplay_overlay_set };
static SwigPyGetSet TextureDisplay_resourceId_getset = { _wrap_TextureDisplay_resourceId_get, _wrap_TextureDisplay_resourceId_set };
static SwigPyGetSet TextureDisplay_rangeMin_getset = { _wrap_TextureDisplay_rangeMin_get, _wrap_TextureDisplay_rangeMin_set };
static SwigPyGetSet TextureDisplay_alpha_getset = { _wrap_TextureDisplay_alpha_get, _wrap_TextureDisplay_alpha_set };
static SwigPyGetSet TextureDisplay_decodeYUV_getset = { _wrap_TextureDisplay_decodeYUV_get, _wrap_TextureDisplay_decodeYUV_set };
static SwigPyGetSet TextureDisplay___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet TextureDisplay_blue_getset = { _wrap_TextureDisplay_blue_get, _wrap_TextureDisplay_blue_set };
static SwigPyGetSet TextureDisplay_rawOutput_getset = { _wrap_TextureDisplay_rawOutput_get, _wrap_TextureDisplay_rawOutput_set };
static SwigPyGetSet TextureDisplay_typeCast_getset = { _wrap_TextureDisplay_typeCast_get, _wrap_TextureDisplay_typeCast_set };
static SwigPyGetSet TextureDisplay_yOffset_getset = { _wrap_TextureDisplay_yOffset_get, _wrap_TextureDisplay_yOffset_set };
static SwigPyGetSet TextureDisplay_customShaderId_getset = { _wrap_TextureDisplay_customShaderId_get, _wrap_TextureDisplay_customShaderId_set };
static SwigPyGetSet TextureDisplay_green_getset = { _wrap_TextureDisplay_green_get, _wrap_TextureDisplay_green_set };
static SwigPyGetSet TextureDisplay_scale_getset = { _wrap_TextureDisplay_scale_get, _wrap_TextureDisplay_scale_set };
static SwigPyGetSet TextureDisplay_subresource_getset = { _wrap_TextureDisplay_subresource_get, _wrap_TextureDisplay_subresource_set };
static SwigPyGetSet TextureDisplay_xOffset_getset = { _wrap_TextureDisplay_xOffset_get, _wrap_TextureDisplay_xOffset_set };
static SwigPyGetSet TextureDisplay_rangeMax_getset = { _wrap_TextureDisplay_rangeMax_get, _wrap_TextureDisplay_rangeMax_set };
static SwigPyGetSet TextureDisplay_red_getset = { _wrap_TextureDisplay_red_get, _wrap_TextureDisplay_red_set };
static SwigPyGetSet TextureDisplay_flipY_getset = { _wrap_TextureDisplay_flipY_get, _wrap_TextureDisplay_flipY_set };
static SwigPyGetSet TextureDisplay_hdrMultiplier_getset = { _wrap_TextureDisplay_hdrMultiplier_get, _wrap_TextureDisplay_hdrMultiplier_set };
static SwigPyGetSet TextureDisplay_linearDisplayAsGamma_getset = { _wrap_TextureDisplay_linearDisplayAsGamma_get, _wrap_TextureDisplay_linearDisplayAsGamma_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TextureDisplay_getset[] = {
    { (char *) "backgroundColor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The background color to use behind the texture display.\n"
		"\n"
		"If set to (0, 0, 0, 0) the global checkerboard colors are used.\n"
		"\n"
		":type: FloatVector\n"
		"\n"
		"", (void *) &TextureDisplay_backgroundColor_getset }
,
    { (char *) "overlay", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Selects a :class:`DebugOverlay` to draw over the top of the texture.\n"
		"\n"
		":type: DebugOverlay\n"
		"\n"
		"", (void *) &TextureDisplay_overlay_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the texture to display.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &TextureDisplay_resourceId_getset }
,
    { (char *) "rangeMin", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value in each channel to map to the black point.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &TextureDisplay_rangeMin_getset }
,
    { (char *) "alpha", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the alpha channel should be visible. If enabled with any of RGB, the\n"
		"texture will be blended to the background color or checkerboard.\n"
		"\n"
		"If only one channel is selected, it will be rendered in grayscale\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &TextureDisplay_alpha_getset }
,
    { (char *) "decodeYUV", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the texture should be decoded as if it contains YUV data.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &TextureDisplay_decodeYUV_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TextureDisplay.__dict__", (void *) &TextureDisplay___dict___getset }
,
    { (char *) "blue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the blue channel should be visible.\n"
		"\n"
		"If only one channel is selected, it will be rendered in grayscale\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &TextureDisplay_blue_getset }
,
    { (char *) "rawOutput", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the rendered image should be as close as possible in value to the input.\n"
		"\n"
		"This is primarily useful when rendering to a floating point target for retrieving pixel data from\n"
		"the input texture in cases where it isn't easy to directly fetch the input texture data.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &TextureDisplay_rawOutput_getset }
,
    { (char *) "typeCast", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If possible interpret the texture with this type instead of its normal type.\n"
		"\n"
		"If set to :data:`CompType.Typeless` then no cast is applied, otherwise where allowed the texture\n"
		"data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned normalised\n"
		"values.\n"
		"\n"
		":type: CompType\n"
		"\n"
		"", (void *) &TextureDisplay_typeCast_getset }
,
    { (char *) "yOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset to pan in the Y axis.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &TextureDisplay_yOffset_getset }
,
    { (char *) "customShaderId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of a custom shader to use when rendering.\n"
		"\n"
		"See :meth:`ReplayController.BuildCustomShader` for creating an appropriate custom shader.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &TextureDisplay_customShaderId_getset }
,
    { (char *) "green", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the green channel should be visible.\n"
		"\n"
		"If only one channel is selected, it will be rendered in grayscale\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &TextureDisplay_green_getset }
,
    { (char *) "scale", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The scale to apply to the texture when rendering as a floating point value.\n"
		"\n"
		"``1.0`` corresponds to ``100%``\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &TextureDisplay_scale_getset }
,
    { (char *) "subresource", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The subresource of the texture to display.\n"
		"\n"
		"If the :data:`Subresource.sample` member is set to :data:`ResolveSamples` then a default resolve\n"
		"will be performed that averages all samples.\n"
		"\n"
		":type: Subresource\n"
		"\n"
		"", (void *) &TextureDisplay_subresource_getset }
,
    { (char *) "xOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset to pan in the X axis.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &TextureDisplay_xOffset_getset }
,
    { (char *) "rangeMax", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value in each channel to map to the white point.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &TextureDisplay_rangeMax_getset }
,
    { (char *) "red", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the red channel should be visible.\n"
		"\n"
		"If only one channel is selected, it will be rendered in grayscale\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &TextureDisplay_red_getset }
,
    { (char *) "flipY", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the texture should be flipped vertically when rendering.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &TextureDisplay_flipY_getset }
,
    { (char *) "hdrMultiplier", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If ``>= 0.0`` the RGBA values will be viewed as HDRM with this as the multiplier.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &TextureDisplay_hdrMultiplier_getset }
,
    { (char *) "linearDisplayAsGamma", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the texture should be interpreted as gamma.\n"
		"\n"
		"See :ref:`the FAQ entry <gamma-linear-display>`.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &TextureDisplay_linearDisplayAsGamma_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TextureDisplay_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TextureDisplay_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TextureDisplay_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.TextureDisplay",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TextureDisplay_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TextureDisplay_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__TextureDisplay_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__TextureDisplay_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TextureDisplay_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"\n"
		"Describes how to render a texture preview of an image. Describes the zoom and pan settings for the\n"
		"texture when rendering on a particular output, as well as the modification and selection of a\n"
		"particular subresource (such as array slice, mip or multi-sampled sample).\n"
		"\n"
		".. note::\n"
		"  X and Y co-ordinates are always considered to be top-left, even on GL, for consistency between\n"
		"  APIs and preventing the need for API-specific code in most cases. This means if co-ordinates are\n"
		"  fetched from e.g. viewport or scissor data or other GL pipeline state which is perhaps in\n"
		"  bottom-left co-ordinates, care must be taken to translate them.\n"
		"\n"
		".. data:: ResolveSamples\n"
		"\n"
		"  Value for :data:`sampleIdx` if the samples should be averaged.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TextureDisplay_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TextureDisplay_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TextureDisplay_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TextureDisplay,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TextureDisplay_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TextureDisplay_type};

static SwigPyGetSet TextureComponentMapping_whitePoint_getset = { _wrap_TextureComponentMapping_whitePoint_get, _wrap_TextureComponentMapping_whitePoint_set };
static SwigPyGetSet TextureComponentMapping___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet TextureComponentMapping_blackPoint_getset = { _wrap_TextureComponentMapping_blackPoint_get, _wrap_TextureComponentMapping_blackPoint_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TextureComponentMapping_getset[] = {
    { (char *) "whitePoint", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value that should be mapped to ``255``\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &TextureComponentMapping_whitePoint_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TextureComponentMapping.__dict__", (void *) &TextureComponentMapping___dict___getset }
,
    { (char *) "blackPoint", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value that should be mapped to ``0``\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &TextureComponentMapping_blackPoint_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TextureComponentMapping_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TextureComponentMapping_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TextureComponentMapping_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.TextureComponentMapping",      /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TextureComponentMapping_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TextureComponentMapping_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__TextureComponentMapping_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__TextureComponentMapping_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TextureComponentMapping_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "How to map components to normalised ``[0, 255]`` for saving to 8-bit file formats.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TextureComponentMapping_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TextureComponentMapping_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TextureComponentMapping_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TextureComponentMapping,                 /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TextureComponentMapping_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TextureComponentMapping_type};

static SwigPyGetSet TextureSampleMapping_sampleIndex_getset = { _wrap_TextureSampleMapping_sampleIndex_get, _wrap_TextureSampleMapping_sampleIndex_set };
static SwigPyGetSet TextureSampleMapping___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet TextureSampleMapping_mapToArray_getset = { _wrap_TextureSampleMapping_mapToArray_get, _wrap_TextureSampleMapping_mapToArray_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TextureSampleMapping_getset[] = {
    { (char *) "sampleIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"\n"
		"If :data:`mapToArray` is ``False`` this selects which sample should be extracted to treat as a\n"
		"normal 2D image. If set to :data:`ResolveSamples` then instead there's a default average resolve.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureSampleMapping_sampleIndex_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TextureSampleMapping.__dict__", (void *) &TextureSampleMapping___dict___getset }
,
    { (char *) "mapToArray", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"\n"
		"``True`` if the samples should be mapped to array slices. A multisampled array expands each slice\n"
		"in-place, so it would be slice 0: sample 0, slice 0: sample 1, slice 1: sample 0, etc.\n"
		"\n"
		"This then follows the mapping for array slices as with any other array texture. :data:`sampleIndex`\n"
		"is ignored.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &TextureSampleMapping_mapToArray_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TextureSampleMapping_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TextureSampleMapping_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TextureSampleMapping_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.TextureSampleMapping",         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TextureSampleMapping_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TextureSampleMapping_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__TextureSampleMapping_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__TextureSampleMapping_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TextureSampleMapping_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"How to map multisampled textures for saving to non-multisampled file formats.\n"
		"\n"
		".. data:: ResolveSamples\n"
		"\n"
		"  Value for :data:`sampleIndex` if the samples should be averaged.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TextureSampleMapping_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TextureSampleMapping_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TextureSampleMapping_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TextureSampleMapping,/* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TextureSampleMapping_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TextureSampleMapping_type};

static SwigPyGetSet TextureSliceMapping_slicesAsGrid_getset = { _wrap_TextureSliceMapping_slicesAsGrid_get, _wrap_TextureSliceMapping_slicesAsGrid_set };
static SwigPyGetSet TextureSliceMapping_sliceIndex_getset = { _wrap_TextureSliceMapping_sliceIndex_get, _wrap_TextureSliceMapping_sliceIndex_set };
static SwigPyGetSet TextureSliceMapping_cubeCruciform_getset = { _wrap_TextureSliceMapping_cubeCruciform_get, _wrap_TextureSliceMapping_cubeCruciform_set };
static SwigPyGetSet TextureSliceMapping___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet TextureSliceMapping_sliceGridWidth_getset = { _wrap_TextureSliceMapping_sliceGridWidth_get, _wrap_TextureSliceMapping_sliceGridWidth_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TextureSliceMapping_getset[] = {
    { (char *) "slicesAsGrid", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"\n"
		"If ``True``, write out the slices as a 2D grid with the width given in :data:`sliceGridWidth`. Any\n"
		"empty slices in the grid are written as transparent black.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &TextureSliceMapping_slicesAsGrid_getset }
,
    { (char *) "sliceIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"\n"
		"Selects the (depth/array) slice to save.\n"
		"\n"
		"If this is -1, then all slices are written out as detailed below. This is only supported in formats\n"
		"that don't support slices natively, and will be done in RGBA8.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureSliceMapping_sliceIndex_getset }
,
    { (char *) "cubeCruciform", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Write out 6 slices in a cruciform pattern::\n"
		"\n"
		"          +----+\n"
		"          | +y |\n"
		"          |    |\n"
		"     +----+----+----+----+\n"
		"     | -x | +z | +x | -z |\n"
		"     |    |    |    |    |\n"
		"     +----+----+----+----+\n"
		"          | -y |\n"
		"          |    |\n"
		"          +----+\n"
		"\n"
		"With the gaps filled in with transparent black.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &TextureSliceMapping_cubeCruciform_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TextureSliceMapping.__dict__", (void *) &TextureSliceMapping___dict___getset }
,
    { (char *) "sliceGridWidth", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The width of a grid if :data:`slicesAsGrid` is ``True``.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureSliceMapping_sliceGridWidth_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TextureSliceMapping_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TextureSliceMapping_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TextureSliceMapping_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.TextureSliceMapping",          /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TextureSliceMapping_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TextureSliceMapping_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__TextureSliceMapping_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__TextureSliceMapping_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TextureSliceMapping_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"How to map array textures for saving to non-arrayed file formats.\n"
		"\n"
		"If :data:`sliceIndex` is -1, :data:`cubeCruciform` == :data:`slicesAsGrid` == ``False`` and the file\n"
		"format doesn't support saving all slices, only slice 0 is saved.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TextureSliceMapping_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TextureSliceMapping_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TextureSliceMapping_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TextureSliceMapping, /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TextureSliceMapping_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TextureSliceMapping_type};

static SwigPyGetSet TextureSave_destType_getset = { _wrap_TextureSave_destType_get, _wrap_TextureSave_destType_set };
static SwigPyGetSet TextureSave_jpegQuality_getset = { _wrap_TextureSave_jpegQuality_get, _wrap_TextureSave_jpegQuality_set };
static SwigPyGetSet TextureSave_resourceId_getset = { _wrap_TextureSave_resourceId_get, _wrap_TextureSave_resourceId_set };
static SwigPyGetSet TextureSave_comp_getset = { _wrap_TextureSave_comp_get, _wrap_TextureSave_comp_set };
static SwigPyGetSet TextureSave_alpha_getset = { _wrap_TextureSave_alpha_get, _wrap_TextureSave_alpha_set };
static SwigPyGetSet TextureSave_channelExtract_getset = { _wrap_TextureSave_channelExtract_get, _wrap_TextureSave_channelExtract_set };
static SwigPyGetSet TextureSave___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet TextureSave_slice_getset = { _wrap_TextureSave_slice_get, _wrap_TextureSave_slice_set };
static SwigPyGetSet TextureSave_typeCast_getset = { _wrap_TextureSave_typeCast_get, _wrap_TextureSave_typeCast_set };
static SwigPyGetSet TextureSave_sample_getset = { _wrap_TextureSave_sample_get, _wrap_TextureSave_sample_set };
static SwigPyGetSet TextureSave_mip_getset = { _wrap_TextureSave_mip_get, _wrap_TextureSave_mip_set };
static SwigPyGetSet TextureSave_alphaCol_getset = { _wrap_TextureSave_alphaCol_get, _wrap_TextureSave_alphaCol_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TextureSave_getset[] = {
    { (char *) "destType", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`FileType` to use when saving to the destination file.\n"
		"\n"
		":type: FileType\n"
		"\n"
		"", (void *) &TextureSave_destType_getset }
,
    { (char *) "jpegQuality", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The quality to use when saving to a ``JPG`` file. Valid values are between 1 and 100.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureSave_jpegQuality_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the texture to save.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &TextureSave_resourceId_getset }
,
    { (char *) "comp", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Controls black/white point mapping for output formats that are normal\n"
		":attr:`8-bit SRGB <CompType.UNorm>`, values are truncated so that values below the black point\n"
		"and above the white point are clamped, and the values in between are evenly distributed.\n"
		"\n"
		":type: TextureComponentMapping\n"
		"\n"
		"", (void *) &TextureSave_comp_getset }
,
    { (char *) "alpha", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Controls handling of alpha channel, only relevant for file formats that don't have\n"
		"alpha.\n"
		"\n"
		"It is an :class:`AlphaMapping` that controls what behaviour to use.\n"
		"\n"
		":type: AlphaMapping\n"
		"\n"
		"", (void *) &TextureSave_alpha_getset }
,
    { (char *) "channelExtract", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Selects a single component out of a texture to save as grayscale, or -1 to save all.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureSave_channelExtract_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TextureSave.__dict__", (void *) &TextureSave___dict___getset }
,
    { (char *) "slice", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Controls mapping for arrayed textures (ignored if texture is not arrayed)\n"
		"\n"
		":type: TextureSliceMapping\n"
		"\n"
		"", (void *) &TextureSave_slice_getset }
,
    { (char *) "typeCast", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If possible interpret the texture with this type instead of its normal type.\n"
		"\n"
		"If set to :data:`CompType.Typeless` then no cast is applied, otherwise where allowed the texture\n"
		"data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned normalised\n"
		"values.\n"
		"\n"
		":type: CompType\n"
		"\n"
		"", (void *) &TextureSave_typeCast_getset }
,
    { (char *) "sample", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Controls mapping for multisampled textures (ignored if texture is not multisampled)\n"
		"\n"
		":type: TextureSampleMapping\n"
		"\n"
		"", (void *) &TextureSave_sample_getset }
,
    { (char *) "mip", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Selects the mip to be written out.\n"
		"\n"
		"If set to ``-1`` then all mips are written, where allowed by file format. If not allowed, mip 0 is\n"
		"written\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureSave_mip_getset }
,
    { (char *) "alphaCol", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The background color if :data:`alpha` is set to :attr:`AlphaMapping.BlendToColor`.\n"
		"\n"
		":type: FloatVector\n"
		"\n"
		"", (void *) &TextureSave_alphaCol_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TextureSave_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TextureSave_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TextureSave_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.TextureSave",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TextureSave_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TextureSave_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__TextureSave_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__TextureSave_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TextureSave_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a texture to save and how to map it to the destination file format.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TextureSave_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TextureSave_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TextureSave_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TextureSave,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TextureSave_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TextureSave_type};

static SwigPyGetSet DescriptorRange_descriptorSize_getset = { _wrap_DescriptorRange_descriptorSize_get, _wrap_DescriptorRange_descriptorSize_set };
static SwigPyGetSet DescriptorRange_count_getset = { _wrap_DescriptorRange_count_get, _wrap_DescriptorRange_count_set };
static SwigPyGetSet DescriptorRange___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet DescriptorRange_offset_getset = { _wrap_DescriptorRange_offset_get, _wrap_DescriptorRange_offset_set };
static SwigPyGetSet DescriptorRange_type_getset = { _wrap_DescriptorRange_type_get, _wrap_DescriptorRange_type_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DescriptorRange_getset[] = {
    { (char *) "descriptorSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size of each descriptor in the range.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DescriptorRange_descriptorSize_getset }
,
    { (char *) "count", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of descriptors in this range.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DescriptorRange_count_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DescriptorRange.__dict__", (void *) &DescriptorRange___dict___getset }
,
    { (char *) "offset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in the descriptor storage where the descriptor range starts.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DescriptorRange_offset_getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The type of descriptor in the descriptor range.\n"
		"\n"
		":type: DescriptorType\n"
		"\n"
		"", (void *) &DescriptorRange_type_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DescriptorRange_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_DescriptorRange___eq__(self, other); break;
    case Py_LT : result = _wrap_DescriptorRange___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DescriptorRange_methods[] = {
  { "__eq__", (PyCFunction) _wrap_DescriptorRange___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_DescriptorRange___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DescriptorRange_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.DescriptorRange",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DescriptorRange_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DescriptorRange_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__DescriptorRange_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__DescriptorRange_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DescriptorRange_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A range of sized descriptors.",          /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DescriptorRange_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DescriptorRange_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DescriptorRange_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DescriptorRange,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DescriptorRange_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DescriptorRange_type};

static SwigPyGetSet NewCaptureData_frameNumber_getset = { _wrap_NewCaptureData_frameNumber_get, _wrap_NewCaptureData_frameNumber_set };
static SwigPyGetSet NewCaptureData_title_getset = { _wrap_NewCaptureData_title_get, _wrap_NewCaptureData_title_set };
static SwigPyGetSet NewCaptureData___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet NewCaptureData_thumbHeight_getset = { _wrap_NewCaptureData_thumbHeight_get, _wrap_NewCaptureData_thumbHeight_set };
static SwigPyGetSet NewCaptureData_path_getset = { _wrap_NewCaptureData_path_get, _wrap_NewCaptureData_path_set };
static SwigPyGetSet NewCaptureData_captureId_getset = { _wrap_NewCaptureData_captureId_get, _wrap_NewCaptureData_captureId_set };
static SwigPyGetSet NewCaptureData_byteSize_getset = { _wrap_NewCaptureData_byteSize_get, _wrap_NewCaptureData_byteSize_set };
static SwigPyGetSet NewCaptureData_local_getset = { _wrap_NewCaptureData_local_get, _wrap_NewCaptureData_local_set };
static SwigPyGetSet NewCaptureData_thumbWidth_getset = { _wrap_NewCaptureData_thumbWidth_get, _wrap_NewCaptureData_thumbWidth_set };
static SwigPyGetSet NewCaptureData_timestamp_getset = { _wrap_NewCaptureData_timestamp_get, _wrap_NewCaptureData_timestamp_set };
static SwigPyGetSet NewCaptureData_thumbnail_getset = { _wrap_NewCaptureData_thumbnail_get, _wrap_NewCaptureData_thumbnail_set };
static SwigPyGetSet NewCaptureData_api_getset = { _wrap_NewCaptureData_api_get, _wrap_NewCaptureData_api_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__NewCaptureData_getset[] = {
    { (char *) "frameNumber", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The frame number that this capture came from.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &NewCaptureData_frameNumber_getset }
,
    { (char *) "title", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The custom title for this capture, if empty a default title can be used.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &NewCaptureData_title_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"NewCaptureData.__dict__", (void *) &NewCaptureData___dict___getset }
,
    { (char *) "thumbHeight", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The height of the image contained in :data:`thumbnail`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &NewCaptureData_thumbHeight_getset }
,
    { (char *) "path", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The local path on the target system where the capture is saved.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &NewCaptureData_path_getset }
,
    { (char *) "captureId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An identifier to use to refer to this capture.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &NewCaptureData_captureId_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size of the capture, in bytes.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &NewCaptureData_byteSize_getset }
,
    { (char *) "local", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the target is running on the local system.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &NewCaptureData_local_getset }
,
    { (char *) "thumbWidth", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The width of the image contained in :data:`thumbnail`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &NewCaptureData_thumbWidth_getset }
,
    { (char *) "timestamp", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The time the capture was created, as a unix timestamp in UTC.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &NewCaptureData_timestamp_getset }
,
    { (char *) "thumbnail", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The raw bytes that contain the capture thumbnail, as RGB8 data.\n"
		"\n"
		":type: bytes\n"
		"\n"
		"", (void *) &NewCaptureData_thumbnail_getset }
,
    { (char *) "api", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The API used for this capture, if available.\n"
		"\n"
		".. note::\n"
		"  May be empty if running with an older version of RenderDoc\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &NewCaptureData_api_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__NewCaptureData_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__NewCaptureData_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__NewCaptureData_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.NewCaptureData",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_NewCaptureData_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__NewCaptureData_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__NewCaptureData_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__NewCaptureData_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__NewCaptureData_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Information about the a new capture created by the target.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__NewCaptureData_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__NewCaptureData_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__NewCaptureData_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_NewCaptureData,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__NewCaptureData_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__NewCaptureData_type};

static SwigPyGetSet APIUseData_name_getset = { _wrap_APIUseData_name_get, _wrap_APIUseData_name_set };
static SwigPyGetSet APIUseData_presenting_getset = { _wrap_APIUseData_presenting_get, _wrap_APIUseData_presenting_set };
static SwigPyGetSet APIUseData_supportMessage_getset = { _wrap_APIUseData_supportMessage_get, _wrap_APIUseData_supportMessage_set };
static SwigPyGetSet APIUseData___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet APIUseData_supported_getset = { _wrap_APIUseData_supported_get, _wrap_APIUseData_supported_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__APIUseData_getset[] = {
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of the API.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &APIUseData_name_getset }
,
    { (char *) "presenting", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the API is presenting to a swapchain\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &APIUseData_presenting_getset }
,
    { (char *) "supportMessage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A string message if the API is unsupported explaining why.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &APIUseData_supportMessage_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"APIUseData.__dict__", (void *) &APIUseData___dict___getset }
,
    { (char *) "supported", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the API can be captured.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &APIUseData_supported_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__APIUseData_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__APIUseData_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__APIUseData_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.APIUseData",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_APIUseData_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__APIUseData_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__APIUseData_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__APIUseData_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__APIUseData_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Information about the API that the target is using.",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__APIUseData_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__APIUseData_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__APIUseData_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_APIUseData,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__APIUseData_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__APIUseData_type};

static SwigPyGetSet BusyData_clientName_getset = { _wrap_BusyData_clientName_get, _wrap_BusyData_clientName_set };
static SwigPyGetSet BusyData___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__BusyData_getset[] = {
    { (char *) "clientName", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of the client currently connected to the target.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &BusyData_clientName_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"BusyData.__dict__", (void *) &BusyData___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__BusyData_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__BusyData_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__BusyData_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.BusyData",                     /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_BusyData_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__BusyData_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__BusyData_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__BusyData_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__BusyData_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Information about why the target is busy.",                  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__BusyData_richcompare,            /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__BusyData_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__BusyData_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_BusyData,            /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__BusyData_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__BusyData_type};

static SwigPyGetSet NewChildData___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet NewChildData_ident_getset = { _wrap_NewChildData_ident_get, _wrap_NewChildData_ident_set };
static SwigPyGetSet NewChildData_processId_getset = { _wrap_NewChildData_processId_get, _wrap_NewChildData_processId_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__NewChildData_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"NewChildData.__dict__", (void *) &NewChildData___dict___getset }
,
    { (char *) "ident", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The ident where the new child's target control is active.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &NewChildData_ident_getset }
,
    { (char *) "processId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The PID (Process ID) of the new child.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &NewChildData_processId_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__NewChildData_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__NewChildData_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__NewChildData_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.NewChildData",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_NewChildData_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__NewChildData_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__NewChildData_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__NewChildData_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__NewChildData_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Information about a new child process spawned by the target.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__NewChildData_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__NewChildData_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__NewChildData_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_NewChildData,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__NewChildData_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__NewChildData_type};

static SwigPyGetSet TargetControlMessage_newCapture_getset = { _wrap_TargetControlMessage_newCapture_get, _wrap_TargetControlMessage_newCapture_set };
static SwigPyGetSet TargetControlMessage_busy_getset = { _wrap_TargetControlMessage_busy_get, _wrap_TargetControlMessage_busy_set };
static SwigPyGetSet TargetControlMessage_apiUse_getset = { _wrap_TargetControlMessage_apiUse_get, _wrap_TargetControlMessage_apiUse_set };
static SwigPyGetSet TargetControlMessage___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet TargetControlMessage_type_getset = { _wrap_TargetControlMessage_type_get, _wrap_TargetControlMessage_type_set };
static SwigPyGetSet TargetControlMessage_newChild_getset = { _wrap_TargetControlMessage_newChild_get, _wrap_TargetControlMessage_newChild_set };
static SwigPyGetSet TargetControlMessage_capProgress_getset = { _wrap_TargetControlMessage_capProgress_get, _wrap_TargetControlMessage_capProgress_set };
static SwigPyGetSet TargetControlMessage_capturableWindowCount_getset = { _wrap_TargetControlMessage_capturableWindowCount_get, _wrap_TargetControlMessage_capturableWindowCount_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TargetControlMessage_getset[] = {
    { (char *) "newCapture", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The new capture data.\n"
		"\n"
		":type: NewCaptureData\n"
		"\n"
		"", (void *) &TargetControlMessage_newCapture_getset }
,
    { (char *) "busy", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The busy signal data.\n"
		"\n"
		":type: BusyData\n"
		"\n"
		"", (void *) &TargetControlMessage_busy_getset }
,
    { (char *) "apiUse", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The API use data.\n"
		"\n"
		":type: APIUseData\n"
		"\n"
		"", (void *) &TargetControlMessage_apiUse_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TargetControlMessage.__dict__", (void *) &TargetControlMessage___dict___getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`type <TargetControlMessageType>` of message received\n"
		"\n"
		":type: TargetControlMessageType\n"
		"\n"
		"", (void *) &TargetControlMessage_type_getset }
,
    { (char *) "newChild", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The new child process data.\n"
		"\n"
		":type: NewChildData\n"
		"\n"
		"", (void *) &TargetControlMessage_newChild_getset }
,
    { (char *) "capProgress", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The progress of an on-going capture.\n"
		"\n"
		"When valid, will be in the range of 0.0 to 1.0 (0 - 100%). If not valid when a capture isn't going\n"
		"or has finished, it will be -1.0\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &TargetControlMessage_capProgress_getset }
,
    { (char *) "capturableWindowCount", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of the capturable windows\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TargetControlMessage_capturableWindowCount_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TargetControlMessage_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TargetControlMessage_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TargetControlMessage_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.TargetControlMessage",         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TargetControlMessage_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TargetControlMessage_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__TargetControlMessage_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__TargetControlMessage_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TargetControlMessage_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A message from a target control connection.",                /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TargetControlMessage_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TargetControlMessage_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TargetControlMessage_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TargetControlMessage,/* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TargetControlMessage_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TargetControlMessage_type};

static SwigPyGetSet EnvironmentModification_value_getset = { _wrap_EnvironmentModification_value_get, _wrap_EnvironmentModification_value_set };
static SwigPyGetSet EnvironmentModification_name_getset = { _wrap_EnvironmentModification_name_get, _wrap_EnvironmentModification_name_set };
static SwigPyGetSet EnvironmentModification___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet EnvironmentModification_mod_getset = { _wrap_EnvironmentModification_mod_get, _wrap_EnvironmentModification_mod_set };
static SwigPyGetSet EnvironmentModification_sep_getset = { _wrap_EnvironmentModification_sep_get, _wrap_EnvironmentModification_sep_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__EnvironmentModification_getset[] = {
    { (char *) "value", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value to use with the modification specified in :data:`mod`.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &EnvironmentModification_value_getset }
,
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of the environment variable.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &EnvironmentModification_name_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"EnvironmentModification.__dict__", (void *) &EnvironmentModification___dict___getset }
,
    { (char *) "mod", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`modification <EnvMod>` to use.\n"
		"\n"
		":type: EnvMod\n"
		"\n"
		"", (void *) &EnvironmentModification_mod_getset }
,
    { (char *) "sep", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`separator <EnvSep>` to use if needed.\n"
		"\n"
		":type: EnvSep\n"
		"\n"
		"", (void *) &EnvironmentModification_sep_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__EnvironmentModification_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_EnvironmentModification___eq__(self, other); break;
    case Py_LT : result = _wrap_EnvironmentModification___lt__(self, other); break;
    case Py_NE : result = _wrap_EnvironmentModification___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__EnvironmentModification_methods[] = {
  { "__lt__", (PyCFunction) _wrap_EnvironmentModification___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_EnvironmentModification___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_EnvironmentModification___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__EnvironmentModification_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.EnvironmentModification",      /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_EnvironmentModification_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__EnvironmentModification_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__EnvironmentModification_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__EnvironmentModification_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__EnvironmentModification_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A modification to a single environment variable.",           /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__EnvironmentModification_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__EnvironmentModification_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__EnvironmentModification_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_EnvironmentModification,                 /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__EnvironmentModification_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__EnvironmentModification_type};

static SwigPyGetSet CaptureFileFormat_name_getset = { _wrap_CaptureFileFormat_name_get, _wrap_CaptureFileFormat_name_set };
static SwigPyGetSet CaptureFileFormat_requiresBuffers_getset = { _wrap_CaptureFileFormat_requiresBuffers_get, _wrap_CaptureFileFormat_requiresBuffers_set };
static SwigPyGetSet CaptureFileFormat___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet CaptureFileFormat_description_getset = { _wrap_CaptureFileFormat_description_get, _wrap_CaptureFileFormat_description_set };
static SwigPyGetSet CaptureFileFormat_openSupported_getset = { _wrap_CaptureFileFormat_openSupported_get, _wrap_CaptureFileFormat_openSupported_set };
static SwigPyGetSet CaptureFileFormat_convertSupported_getset = { _wrap_CaptureFileFormat_convertSupported_get, _wrap_CaptureFileFormat_convertSupported_set };
static SwigPyGetSet CaptureFileFormat_extension_getset = { _wrap_CaptureFileFormat_extension_get, _wrap_CaptureFileFormat_extension_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CaptureFileFormat_getset[] = {
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A human readable short phrase naming the file format.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &CaptureFileFormat_name_getset }
,
    { (char *) "requiresBuffers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Indicates whether exporting to this format requires buffers or just structured data.\n"
		"If it doesn't require buffers then it can be exported directly from an opened capture, which by\n"
		"default has structured data but no buffers available.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &CaptureFileFormat_requiresBuffers_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"CaptureFileFormat.__dict__", (void *) &CaptureFileFormat___dict___getset }
,
    { (char *) "description", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A human readable long-form description of the file format.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &CaptureFileFormat_description_getset }
,
    { (char *) "openSupported", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Indicates whether or not files in this format can be opened and processed as\n"
		"structured data.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &CaptureFileFormat_openSupported_getset }
,
    { (char *) "convertSupported", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Indicates whether captures or structured data can be saved out in this format.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &CaptureFileFormat_convertSupported_getset }
,
    { (char *) "extension", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The file of the format as a single minimal string, e.g. ``rdc``.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &CaptureFileFormat_extension_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__CaptureFileFormat_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_CaptureFileFormat___eq__(self, other); break;
    case Py_LT : result = _wrap_CaptureFileFormat___lt__(self, other); break;
    case Py_NE : result = _wrap_CaptureFileFormat___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__CaptureFileFormat_methods[] = {
  { "__lt__", (PyCFunction) _wrap_CaptureFileFormat___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_CaptureFileFormat___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_CaptureFileFormat___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__CaptureFileFormat_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.CaptureFileFormat",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_CaptureFileFormat_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__CaptureFileFormat_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__CaptureFileFormat_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__CaptureFileFormat_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__CaptureFileFormat_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The format for a capture file either supported to read from, or export to",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__CaptureFileFormat_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__CaptureFileFormat_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__CaptureFileFormat_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_CaptureFileFormat,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__CaptureFileFormat_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CaptureFileFormat_type};

static SwigPyGetSet GPUDevice_deviceID_getset = { _wrap_GPUDevice_deviceID_get, _wrap_GPUDevice_deviceID_set };
static SwigPyGetSet GPUDevice_apis_getset = { _wrap_GPUDevice_apis_get, _wrap_GPUDevice_apis_set };
static SwigPyGetSet GPUDevice_name_getset = { _wrap_GPUDevice_name_get, _wrap_GPUDevice_name_set };
static SwigPyGetSet GPUDevice___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GPUDevice_driver_getset = { _wrap_GPUDevice_driver_get, _wrap_GPUDevice_driver_set };
static SwigPyGetSet GPUDevice_vendor_getset = { _wrap_GPUDevice_vendor_get, _wrap_GPUDevice_vendor_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GPUDevice_getset[] = {
    { (char *) "deviceID", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The PCI deviceID of this GPU.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GPUDevice_deviceID_getset }
,
    { (char *) "apis", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The APIs that this device supports.\n"
		"\n"
		":type: List[GraphicsAPI]\n"
		"\n"
		"", (void *) &GPUDevice_apis_getset }
,
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The human-readable name of this GPU.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &GPUDevice_name_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GPUDevice.__dict__", (void *) &GPUDevice___dict___getset }
,
    { (char *) "driver", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of the driver of this GPU, if multiple drivers are available for it.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &GPUDevice_driver_getset }
,
    { (char *) "vendor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`GPUVendor` of this GPU.\n"
		"\n"
		":type: GPUVendor\n"
		"\n"
		"", (void *) &GPUDevice_vendor_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GPUDevice_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_GPUDevice___eq__(self, other); break;
    case Py_LT : result = _wrap_GPUDevice___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GPUDevice_methods[] = {
  { "__eq__", (PyCFunction) _wrap_GPUDevice___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_GPUDevice___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GPUDevice_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GPUDevice",                    /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GPUDevice_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GPUDevice_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__GPUDevice_type.as_sequence,                   /* tp_as_sequence */
    &SwigPyBuiltin__GPUDevice_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GPUDevice_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a single GPU at replay time.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GPUDevice_richcompare,           /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GPUDevice_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GPUDevice_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GPUDevice,           /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GPUDevice_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GPUDevice_type};

static SwigPyGetSet ReplayOptions_forceGPUDeviceID_getset = { _wrap_ReplayOptions_forceGPUDeviceID_get, _wrap_ReplayOptions_forceGPUDeviceID_set };
static SwigPyGetSet ReplayOptions_optimisation_getset = { _wrap_ReplayOptions_optimisation_get, _wrap_ReplayOptions_optimisation_set };
static SwigPyGetSet ReplayOptions_apiValidation_getset = { _wrap_ReplayOptions_apiValidation_get, _wrap_ReplayOptions_apiValidation_set };
static SwigPyGetSet ReplayOptions___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ReplayOptions_forceGPUVendor_getset = { _wrap_ReplayOptions_forceGPUVendor_get, _wrap_ReplayOptions_forceGPUVendor_set };
static SwigPyGetSet ReplayOptions_forceGPUDriverName_getset = { _wrap_ReplayOptions_forceGPUDriverName_get, _wrap_ReplayOptions_forceGPUDriverName_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ReplayOptions_getset[] = {
    { (char *) "forceGPUDeviceID", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Force the selection of a GPU by device ID. This allows overriding which GPU is used to\n"
		"replay on.\n"
		"\n"
		"When set to 0, specifies no particular device.\n"
		"\n"
		"See :data:`forceGPUDeviceID` for a full explanation of GPU selection override.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ReplayOptions_forceGPUDeviceID_getset }
,
    { (char *) "optimisation", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How much optimisation should be done, potentially at the cost of correctness.\n"
		"\n"
		"The default is :data:`ReplayOptimisationLevel.Balanced`.\n"
		"\n"
		":type: ReplayOptimisationLevel\n"
		"\n"
		"", (void *) &ReplayOptions_optimisation_getset }
,
    { (char *) "apiValidation", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Replay with API validation enabled and use debug messages from there, ignoring any\n"
		"that may be contained in the capture.\n"
		"\n"
		"The default is not to do any validation.\n"
		"\n"
		".. note:: RenderDoc does not handle invalid API use in the general case so validation should still\n"
		"  be performed at runtime in your program for ground truth results.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &ReplayOptions_apiValidation_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ReplayOptions.__dict__", (void *) &ReplayOptions___dict___getset }
,
    { (char *) "forceGPUVendor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Force the selection of a GPU by vendor ID. This allows overriding which GPU is used to\n"
		"replay on, even if a different GPU would be the best match for the capture.\n"
		"\n"
		"When set to :data:`GPUVendor.Unknown`, specifies no particular vendor.\n"
		"\n"
		"See also :data:`forceGPUDeviceID` and :data:`forceGPUDriverName`. Available GPUs can be enumerated\n"
		"using :meth:`CaptureAccess.GetAvailableGPUs`.\n"
		"\n"
		"The default is not to do any override. The capture contains information about what GPU was used, and\n"
		"the closest matching GPU is used on replay.\n"
		"\n"
		".. note::\n"
		"  If a GPU is forced that is not available or not supported for a given capture, such as when GPUs\n"
		"  are only available for some APIs and not others, the default GPU selection will be used. If a GPU\n"
		"  is available for a capture but fails to open however then there is no fallback to a default GPU.\n"
		"\n"
		"  OpenGL does not support GPU selection so the default method (which effectively does nothing) will\n"
		"  always be used.\n"
		"\n"
		":type: GPUVendor\n"
		"\n"
		"", (void *) &ReplayOptions_forceGPUVendor_getset }
,
    { (char *) "forceGPUDriverName", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Force the selection of a GPU by driver name. This allows overriding which GPU is used\n"
		"to replay on.\n"
		"\n"
		"When set to an empty string, specifies no particular driver.\n"
		"\n"
		"See :data:`forceGPUDeviceID` for a full explanation of GPU selection override.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ReplayOptions_forceGPUDriverName_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ReplayOptions_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ReplayOptions_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ReplayOptions_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ReplayOptions",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ReplayOptions_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ReplayOptions_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__ReplayOptions_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__ReplayOptions_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ReplayOptions_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The options controlling how replay of a capture should be performed",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ReplayOptions_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ReplayOptions_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ReplayOptions_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ReplayOptions,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ReplayOptions_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ReplayOptions_type};

static SwigPyGetSet WindowingData___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__WindowingData_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"WindowingData.__dict__", (void *) &WindowingData___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__WindowingData_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__WindowingData_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__WindowingData_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.WindowingData",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_WindowingData_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__WindowingData_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__WindowingData_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__WindowingData_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__WindowingData_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "An opaque structure created to hold windowing setup data",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__WindowingData_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__WindowingData_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__WindowingData_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_WindowingData,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__WindowingData_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__WindowingData_type};

static SwigPyGetSet GlobalEnvironment___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GlobalEnvironment_xlibDisplay_getset = { _wrap_GlobalEnvironment_xlibDisplay_get, _wrap_GlobalEnvironment_xlibDisplay_set };
static SwigPyGetSet GlobalEnvironment_waylandDisplay_getset = { _wrap_GlobalEnvironment_waylandDisplay_get, _wrap_GlobalEnvironment_waylandDisplay_set };
static SwigPyGetSet GlobalEnvironment_enumerateGPUs_getset = { _wrap_GlobalEnvironment_enumerateGPUs_get, _wrap_GlobalEnvironment_enumerateGPUs_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GlobalEnvironment_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GlobalEnvironment.__dict__", (void *) &GlobalEnvironment___dict___getset }
,
    { (char *) "xlibDisplay", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The handle to the X display to use internally. If left ``NULL``, one will be opened.\n"
		"\n"
		":type: Display\n"
		"\n"
		"", (void *) &GlobalEnvironment_xlibDisplay_getset }
,
    { (char *) "waylandDisplay", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The handle to the wayland display to use internally. If left ``NULL``, wayland cannot be used.\n"
		"\n"
		":type: wl_display\n"
		"\n"
		"", (void *) &GlobalEnvironment_waylandDisplay_getset }
,
    { (char *) "enumerateGPUs", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Whether to enumerate available GPUs. If the replay program is only being used for\n"
		"internal operation where enumerating GPUs would be too expensive or problematic, it can be disabled\n"
		"here.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GlobalEnvironment_enumerateGPUs_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GlobalEnvironment_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GlobalEnvironment_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GlobalEnvironment_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GlobalEnvironment",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GlobalEnvironment_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GlobalEnvironment_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__GlobalEnvironment_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__GlobalEnvironment_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GlobalEnvironment_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Structure used for initialising environment in a replay application.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GlobalEnvironment_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GlobalEnvironment_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GlobalEnvironment_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GlobalEnvironment,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GlobalEnvironment_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GlobalEnvironment_type};

static SwigPyGetSet ResultDetails___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ResultDetails_code_getset = { _wrap_ResultDetails_code_get, _wrap_ResultDetails_code_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ResultDetails_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ResultDetails.__dict__", (void *) &ResultDetails___dict___getset }
,
    { (char *) "code", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResultCode` resulting from the operation, indicating success or failure.\n"
		"\n"
		":type: ResultCode\n"
		"\n"
		"", (void *) &ResultDetails_code_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ResultDetails_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ResultDetails___eq__(self, other); break;
    case Py_NE : result = _wrap_ResultDetails___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ResultDetails_methods[] = {
  { "OK", (PyCFunction) _wrap_ResultDetails_OK, METH_NOARGS, (char *) "\n"
		"OK()\n"
		"\n"
		"A simple helper function to check if this result is successful.\n"
		"\n"
		":return: Whether or not this result is successful\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "__nonzero__", (PyCFunction) _wrap_ResultDetails___nonzero__, METH_NOARGS, (char *) "__nonzero__()" },
  { "__eq__", (PyCFunction) _wrap_ResultDetails___eq__, METH_O, (char *) "__eq__(resultCode)" },
  { "__ne__", (PyCFunction) _wrap_ResultDetails___ne__, METH_O, (char *) "__ne__(resultCode)" },
  { "Message", (PyCFunction) _wrap_ResultDetails_Message, METH_NOARGS, (char *) "\n"
		"Message()\n"
		"\n"
		"For error codes, this will contain the stringified error code as well as any optional\n"
		"extra information that is available about the error.\n"
		"\n"
		".. note::\n"
		"\n"
		"  It's not necessary to also display the stringified version of :data:`code` as that is automatically\n"
		"  included in the message.\n"
		"\n"
		":return: A formatted message for failure codes, including the code itself.\n"
		":rtype: str\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ResultDetails_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ResultDetails",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ResultDetails_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) result_str,                    /* tp_repr */
    &SwigPyBuiltin__ResultDetails_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__ResultDetails_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__ResultDetails_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) result_str,                    /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ResultDetails_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A general result from an operation with optional string information for failures.\n"
		"\n"
		"This struct can be compared directly to a :class:`ResultCode` for simple checks of status, and when\n"
		"converted to a string it includes the formatted result code and message as appropriate.\n"
		"\n"
		".. note::\n"
		"\n"
		"  The string information is only valid until :func:`ShutdownReplay` is called. After that point,\n"
		"  accessing the string information is invalid and may crash. Care should be taken if\n"
		"  :func:`ShutdownReplay` is called in response to an error, that the error code is read and saved.\n"
		"\n"
		"  Copying the `ResultDetails` instance is *not* sufficient to preserve the string information. It\n"
		"  should be copied to e.g. a `Tuple[ResultCode, str]` instead.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ResultDetails_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ResultDetails_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ResultDetails_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) (inquiry) _wrap_ResultDetails___nonzero___inquiry_closure,/* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ResultDetails_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ResultDetails_type};

static SwigPyGetSet ExecuteResult___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ExecuteResult_ident_getset = { _wrap_ExecuteResult_ident_get, _wrap_ExecuteResult_ident_set };
static SwigPyGetSet ExecuteResult_result_getset = { _wrap_ExecuteResult_result_get, _wrap_ExecuteResult_result_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ExecuteResult_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ExecuteResult.__dict__", (void *) &ExecuteResult___dict___getset }
,
    { (char *) "ident", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The ident where the new application is listening for target control, or 0 if something\n"
		"went wrong.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ExecuteResult_ident_getset }
,
    { (char *) "result", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResultDetails` resulting from the operation, indicating success or failure.\n"
		"\n"
		":type: ResultDetails\n"
		"\n"
		"", (void *) &ExecuteResult_result_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ExecuteResult_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ExecuteResult_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ExecuteResult_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ExecuteResult",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ExecuteResult_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ExecuteResult_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__ExecuteResult_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__ExecuteResult_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ExecuteResult_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The result of executing or injecting into a program.",       /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ExecuteResult_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ExecuteResult_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ExecuteResult_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ExecuteResult,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ExecuteResult_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ExecuteResult_type};

static SwigPyGetSet Viewport_x_getset = { _wrap_Viewport_x_get, _wrap_Viewport_x_set };
static SwigPyGetSet Viewport_y_getset = { _wrap_Viewport_y_get, _wrap_Viewport_y_set };
static SwigPyGetSet Viewport_maxDepth_getset = { _wrap_Viewport_maxDepth_get, _wrap_Viewport_maxDepth_set };
static SwigPyGetSet Viewport_height_getset = { _wrap_Viewport_height_get, _wrap_Viewport_height_set };
static SwigPyGetSet Viewport_enabled_getset = { _wrap_Viewport_enabled_get, _wrap_Viewport_enabled_set };
static SwigPyGetSet Viewport___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet Viewport_width_getset = { _wrap_Viewport_width_get, _wrap_Viewport_width_set };
static SwigPyGetSet Viewport_minDepth_getset = { _wrap_Viewport_minDepth_get, _wrap_Viewport_minDepth_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__Viewport_getset[] = {
    { (char *) "x", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The X co-ordinate of the viewport.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &Viewport_x_getset }
,
    { (char *) "y", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The Y co-ordinate of the viewport.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &Viewport_y_getset }
,
    { (char *) "maxDepth", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The maximum depth of the viewport.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &Viewport_maxDepth_getset }
,
    { (char *) "height", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The height of the viewport.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &Viewport_height_getset }
,
    { (char *) "enabled", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Is this viewport enabled.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &Viewport_enabled_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"Viewport.__dict__", (void *) &Viewport___dict___getset }
,
    { (char *) "width", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The width of the viewport.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &Viewport_width_getset }
,
    { (char *) "minDepth", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The minimum depth of the viewport.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &Viewport_minDepth_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__Viewport_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_Viewport___eq__(self, other); break;
    case Py_LT : result = _wrap_Viewport___lt__(self, other); break;
    case Py_NE : result = _wrap_Viewport___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__Viewport_methods[] = {
  { "__lt__", (PyCFunction) _wrap_Viewport___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_Viewport___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_Viewport___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__Viewport_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.Viewport",                     /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_Viewport_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__Viewport_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__Viewport_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__Viewport_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__Viewport_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Information about a viewport.",          /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__Viewport_richcompare,            /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__Viewport_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__Viewport_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_Viewport,            /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__Viewport_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__Viewport_type};

static SwigPyGetSet Scissor_x_getset = { _wrap_Scissor_x_get, _wrap_Scissor_x_set };
static SwigPyGetSet Scissor_y_getset = { _wrap_Scissor_y_get, _wrap_Scissor_y_set };
static SwigPyGetSet Scissor_height_getset = { _wrap_Scissor_height_get, _wrap_Scissor_height_set };
static SwigPyGetSet Scissor_enabled_getset = { _wrap_Scissor_enabled_get, _wrap_Scissor_enabled_set };
static SwigPyGetSet Scissor___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet Scissor_width_getset = { _wrap_Scissor_width_get, _wrap_Scissor_width_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__Scissor_getset[] = {
    { (char *) "x", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"X co-ordinate of the scissor region.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Scissor_x_getset }
,
    { (char *) "y", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Y co-ordinate of the scissor region.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Scissor_y_getset }
,
    { (char *) "height", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Height of the scissor region.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Scissor_height_getset }
,
    { (char *) "enabled", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this scissor region is enabled.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &Scissor_enabled_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"Scissor.__dict__", (void *) &Scissor___dict___getset }
,
    { (char *) "width", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Width of the scissor region.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Scissor_width_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__Scissor_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_Scissor___eq__(self, other); break;
    case Py_LT : result = _wrap_Scissor___lt__(self, other); break;
    case Py_NE : result = _wrap_Scissor___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__Scissor_methods[] = {
  { "__lt__", (PyCFunction) _wrap_Scissor___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_Scissor___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_Scissor___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__Scissor_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.Scissor",                      /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_Scissor_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__Scissor_type.as_number,   /* tp_as_number */
    &SwigPyBuiltin__Scissor_type.as_sequence, /* tp_as_sequence */
    &SwigPyBuiltin__Scissor_type.as_mapping,  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__Scissor_type.as_buffer,   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a single scissor region.",     /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__Scissor_richcompare,             /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__Scissor_methods,           /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__Scissor_getset,            /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_Scissor,             /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__Scissor_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__Scissor_type};

static SwigPyGetSet BlendEquation___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet BlendEquation_destination_getset = { _wrap_BlendEquation_destination_get, _wrap_BlendEquation_destination_set };
static SwigPyGetSet BlendEquation_source_getset = { _wrap_BlendEquation_source_get, _wrap_BlendEquation_source_set };
static SwigPyGetSet BlendEquation_operation_getset = { _wrap_BlendEquation_operation_get, _wrap_BlendEquation_operation_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__BlendEquation_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"BlendEquation.__dict__", (void *) &BlendEquation___dict___getset }
,
    { (char *) "destination", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`BlendMultiplier` for the destination blend value.\n"
		"\n"
		":type: BlendMultiplier\n"
		"\n"
		"", (void *) &BlendEquation_destination_getset }
,
    { (char *) "source", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`BlendMultiplier` for the source blend value.\n"
		"\n"
		":type: BlendMultiplier\n"
		"\n"
		"", (void *) &BlendEquation_source_getset }
,
    { (char *) "operation", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`BlendOperation` to use in the blend calculation.\n"
		"\n"
		":type: BlendOperation\n"
		"\n"
		"", (void *) &BlendEquation_operation_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__BlendEquation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_BlendEquation___eq__(self, other); break;
    case Py_LT : result = _wrap_BlendEquation___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__BlendEquation_methods[] = {
  { "__eq__", (PyCFunction) _wrap_BlendEquation___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_BlendEquation___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__BlendEquation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.BlendEquation",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_BlendEquation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__BlendEquation_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__BlendEquation_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__BlendEquation_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__BlendEquation_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the details of a blend operation.",                /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__BlendEquation_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__BlendEquation_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__BlendEquation_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_BlendEquation,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__BlendEquation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__BlendEquation_type};

static SwigPyGetSet ColorBlend_colorBlend_getset = { _wrap_ColorBlend_colorBlend_get, _wrap_ColorBlend_colorBlend_set };
static SwigPyGetSet ColorBlend_enabled_getset = { _wrap_ColorBlend_enabled_get, _wrap_ColorBlend_enabled_set };
static SwigPyGetSet ColorBlend_logicOperationEnabled_getset = { _wrap_ColorBlend_logicOperationEnabled_get, _wrap_ColorBlend_logicOperationEnabled_set };
static SwigPyGetSet ColorBlend___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ColorBlend_writeMask_getset = { _wrap_ColorBlend_writeMask_get, _wrap_ColorBlend_writeMask_set };
static SwigPyGetSet ColorBlend_alphaBlend_getset = { _wrap_ColorBlend_alphaBlend_get, _wrap_ColorBlend_alphaBlend_set };
static SwigPyGetSet ColorBlend_logicOperation_getset = { _wrap_ColorBlend_logicOperation_get, _wrap_ColorBlend_logicOperation_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ColorBlend_getset[] = {
    { (char *) "colorBlend", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The blending equation for color values.\n"
		"\n"
		":type: BlendEquation\n"
		"\n"
		"", (void *) &ColorBlend_colorBlend_getset }
,
    { (char *) "enabled", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if blending is enabled for this target.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &ColorBlend_enabled_getset }
,
    { (char *) "logicOperationEnabled", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the logic operation in :data:`logicOperation` should be used.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &ColorBlend_logicOperationEnabled_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ColorBlend.__dict__", (void *) &ColorBlend___dict___getset }
,
    { (char *) "writeMask", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The mask for writes to the render target.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ColorBlend_writeMask_getset }
,
    { (char *) "alphaBlend", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The blending equation for alpha values.\n"
		"\n"
		":type: BlendEquation\n"
		"\n"
		"", (void *) &ColorBlend_alphaBlend_getset }
,
    { (char *) "logicOperation", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`LogicOperation` to use for logic operations, if\n"
		":data:`logicOperationEnabled` is ``True``.\n"
		"\n"
		":type: LogicOperation\n"
		"\n"
		"", (void *) &ColorBlend_logicOperation_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ColorBlend_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ColorBlend___eq__(self, other); break;
    case Py_LT : result = _wrap_ColorBlend___lt__(self, other); break;
    case Py_NE : result = _wrap_ColorBlend___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ColorBlend_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ColorBlend___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ColorBlend___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_ColorBlend___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ColorBlend_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ColorBlend",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ColorBlend_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ColorBlend_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__ColorBlend_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__ColorBlend_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ColorBlend_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the blend configuration for a given output target.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ColorBlend_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ColorBlend_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ColorBlend_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ColorBlend,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ColorBlend_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ColorBlend_type};

static SwigPyGetSet RasterState_fillMode_getset = { _wrap_RasterState_fillMode_get, _wrap_RasterState_fillMode_set };
static SwigPyGetSet RasterState_cullMode_getset = { _wrap_RasterState_cullMode_get, _wrap_RasterState_cullMode_set };
static SwigPyGetSet RasterState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet RasterState_frontCCW_getset = { _wrap_RasterState_frontCCW_get, _wrap_RasterState_frontCCW_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__RasterState_getset[] = {
    { (char *) "fillMode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The polygon :class:`FillMode`.\n"
		"\n"
		":type: FillMode\n"
		"\n"
		"", (void *) &RasterState_fillMode_getset }
,
    { (char *) "cullMode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The polygon :class:`CullMode`.\n"
		"\n"
		":type: CullMode\n"
		"\n"
		"", (void *) &RasterState_cullMode_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"RasterState.__dict__", (void *) &RasterState___dict___getset }
,
    { (char *) "frontCCW", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if counter-clockwise polygons are front-facing.\n"
		"``False`` if clockwise polygons are front-facing.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &RasterState_frontCCW_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__RasterState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__RasterState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__RasterState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.RasterState",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_RasterState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__RasterState_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__RasterState_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__RasterState_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__RasterState_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a common subset of rasterizing state.",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__RasterState_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__RasterState_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__RasterState_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_RasterState,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__RasterState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__RasterState_type};

static SwigPyGetSet DepthTestState_depthFunction_getset = { _wrap_DepthTestState_depthFunction_get, _wrap_DepthTestState_depthFunction_set };
static SwigPyGetSet DepthTestState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet DepthTestState_depthBounds_getset = { _wrap_DepthTestState_depthBounds_get, _wrap_DepthTestState_depthBounds_set };
static SwigPyGetSet DepthTestState_minDepthBounds_getset = { _wrap_DepthTestState_minDepthBounds_get, _wrap_DepthTestState_minDepthBounds_set };
static SwigPyGetSet DepthTestState_maxDepthBounds_getset = { _wrap_DepthTestState_maxDepthBounds_get, _wrap_DepthTestState_maxDepthBounds_set };
static SwigPyGetSet DepthTestState_depthEnable_getset = { _wrap_DepthTestState_depthEnable_get, _wrap_DepthTestState_depthEnable_set };
static SwigPyGetSet DepthTestState_depthWrites_getset = { _wrap_DepthTestState_depthWrites_get, _wrap_DepthTestState_depthWrites_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DepthTestState_getset[] = {
    { (char *) "depthFunction", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`CompareFunction` to use for testing depth values.\n"
		"\n"
		":type: CompareFunction\n"
		"\n"
		"", (void *) &DepthTestState_depthFunction_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DepthTestState.__dict__", (void *) &DepthTestState___dict___getset }
,
    { (char *) "depthBounds", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth bounds tests should be applied.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &DepthTestState_depthBounds_getset }
,
    { (char *) "minDepthBounds", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The near plane bounding value.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &DepthTestState_minDepthBounds_getset }
,
    { (char *) "maxDepthBounds", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The far plane bounding value.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &DepthTestState_maxDepthBounds_getset }
,
    { (char *) "depthEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth testing should be performed.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &DepthTestState_depthEnable_getset }
,
    { (char *) "depthWrites", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth values should be written to the depth target.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &DepthTestState_depthWrites_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DepthTestState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DepthTestState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DepthTestState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.DepthTestState",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DepthTestState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DepthTestState_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__DepthTestState_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__DepthTestState_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DepthTestState_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a common subset of depth testing state.",          /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DepthTestState_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DepthTestState_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DepthTestState_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DepthTestState,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DepthTestState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DepthTestState_type};

static SwigPyGetSet StencilFace_reference_getset = { _wrap_StencilFace_reference_get, _wrap_StencilFace_reference_set };
static SwigPyGetSet StencilFace_function_getset = { _wrap_StencilFace_function_get, _wrap_StencilFace_function_set };
static SwigPyGetSet StencilFace___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet StencilFace_compareMask_getset = { _wrap_StencilFace_compareMask_get, _wrap_StencilFace_compareMask_set };
static SwigPyGetSet StencilFace_writeMask_getset = { _wrap_StencilFace_writeMask_get, _wrap_StencilFace_writeMask_set };
static SwigPyGetSet StencilFace_failOperation_getset = { _wrap_StencilFace_failOperation_get, _wrap_StencilFace_failOperation_set };
static SwigPyGetSet StencilFace_depthFailOperation_getset = { _wrap_StencilFace_depthFailOperation_get, _wrap_StencilFace_depthFailOperation_set };
static SwigPyGetSet StencilFace_passOperation_getset = { _wrap_StencilFace_passOperation_get, _wrap_StencilFace_passOperation_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__StencilFace_getset[] = {
    { (char *) "reference", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current stencil reference value.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &StencilFace_reference_getset }
,
    { (char *) "function", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"the :class:`CompareFunction` to use for testing stencil values.\n"
		"\n"
		":type: CompareFunction\n"
		"\n"
		"", (void *) &StencilFace_function_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"StencilFace.__dict__", (void *) &StencilFace___dict___getset }
,
    { (char *) "compareMask", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The mask for testing stencil values.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &StencilFace_compareMask_getset }
,
    { (char *) "writeMask", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The mask for writing stencil values.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &StencilFace_writeMask_getset }
,
    { (char *) "failOperation", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`StencilOperation` to apply if the stencil-test fails.\n"
		"\n"
		":type: StencilOperation\n"
		"\n"
		"", (void *) &StencilFace_failOperation_getset }
,
    { (char *) "depthFailOperation", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"the :class:`StencilOperation` to apply if the depth-test fails.\n"
		"\n"
		":type: StencilOperation\n"
		"\n"
		"", (void *) &StencilFace_depthFailOperation_getset }
,
    { (char *) "passOperation", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"the :class:`StencilOperation` to apply if the stencil-test passes.\n"
		"\n"
		":type: StencilOperation\n"
		"\n"
		"", (void *) &StencilFace_passOperation_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__StencilFace_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__StencilFace_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__StencilFace_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.StencilFace",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_StencilFace_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__StencilFace_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__StencilFace_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__StencilFace_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__StencilFace_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the details of a stencil operation.",              /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__StencilFace_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__StencilFace_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__StencilFace_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_StencilFace,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__StencilFace_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__StencilFace_type};

static SwigPyGetSet BoundVBuffer_resourceId_getset = { _wrap_BoundVBuffer_resourceId_get, _wrap_BoundVBuffer_resourceId_set };
static SwigPyGetSet BoundVBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet BoundVBuffer_byteStride_getset = { _wrap_BoundVBuffer_byteStride_get, _wrap_BoundVBuffer_byteStride_set };
static SwigPyGetSet BoundVBuffer_byteOffset_getset = { _wrap_BoundVBuffer_byteOffset_get, _wrap_BoundVBuffer_byteOffset_set };
static SwigPyGetSet BoundVBuffer_byteSize_getset = { _wrap_BoundVBuffer_byteSize_get, _wrap_BoundVBuffer_byteSize_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__BoundVBuffer_getset[] = {
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A :class:`~renderdoc.ResourceId` identifying the buffer.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &BoundVBuffer_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"BoundVBuffer.__dict__", (void *) &BoundVBuffer___dict___getset }
,
    { (char *) "byteStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stride in bytes between the start of one element and the start of the next.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &BoundVBuffer_byteStride_getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in bytes from the start of the buffer to the data.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &BoundVBuffer_byteOffset_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size of the buffer binding, or 0xFFFFFFFF if the whole buffer is bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &BoundVBuffer_byteSize_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__BoundVBuffer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_BoundVBuffer___eq__(self, other); break;
    case Py_LT : result = _wrap_BoundVBuffer___lt__(self, other); break;
    case Py_NE : result = _wrap_BoundVBuffer___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__BoundVBuffer_methods[] = {
  { "__lt__", (PyCFunction) _wrap_BoundVBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_BoundVBuffer___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_BoundVBuffer___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__BoundVBuffer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.BoundVBuffer",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_BoundVBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__BoundVBuffer_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__BoundVBuffer_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__BoundVBuffer_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__BoundVBuffer_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Information about a single vertex or index buffer binding.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__BoundVBuffer_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__BoundVBuffer_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__BoundVBuffer_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_BoundVBuffer,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__BoundVBuffer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__BoundVBuffer_type};

static SwigPyGetSet Descriptor_minLODClamp_getset = { _wrap_Descriptor_minLODClamp_get, _wrap_Descriptor_minLODClamp_set };
static SwigPyGetSet Descriptor_swizzle_getset = { _wrap_Descriptor_swizzle_get, _wrap_Descriptor_swizzle_set };
static SwigPyGetSet Descriptor_firstMip_getset = { _wrap_Descriptor_firstMip_get, _wrap_Descriptor_firstMip_set };
static SwigPyGetSet Descriptor_view_getset = { _wrap_Descriptor_view_get, _wrap_Descriptor_view_set };
static SwigPyGetSet Descriptor_format_getset = { _wrap_Descriptor_format_get, _wrap_Descriptor_format_set };
static SwigPyGetSet Descriptor___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet Descriptor_numSlices_getset = { _wrap_Descriptor_numSlices_get, _wrap_Descriptor_numSlices_set };
static SwigPyGetSet Descriptor_byteOffset_getset = { _wrap_Descriptor_byteOffset_get, _wrap_Descriptor_byteOffset_set };
static SwigPyGetSet Descriptor_counterByteOffset_getset = { _wrap_Descriptor_counterByteOffset_get, _wrap_Descriptor_counterByteOffset_set };
static SwigPyGetSet Descriptor_bufferStructCount_getset = { _wrap_Descriptor_bufferStructCount_get, _wrap_Descriptor_bufferStructCount_set };
static SwigPyGetSet Descriptor_type_getset = { _wrap_Descriptor_type_get, _wrap_Descriptor_type_set };
static SwigPyGetSet Descriptor_flags_getset = { _wrap_Descriptor_flags_get, _wrap_Descriptor_flags_set };
static SwigPyGetSet Descriptor_byteSize_getset = { _wrap_Descriptor_byteSize_get, _wrap_Descriptor_byteSize_set };
static SwigPyGetSet Descriptor_elementByteSize_getset = { _wrap_Descriptor_elementByteSize_get, _wrap_Descriptor_elementByteSize_set };
static SwigPyGetSet Descriptor_firstSlice_getset = { _wrap_Descriptor_firstSlice_get, _wrap_Descriptor_firstSlice_set };
static SwigPyGetSet Descriptor_resource_getset = { _wrap_Descriptor_resource_get, _wrap_Descriptor_resource_set };
static SwigPyGetSet Descriptor_secondary_getset = { _wrap_Descriptor_secondary_get, _wrap_Descriptor_secondary_set };
static SwigPyGetSet Descriptor_numMips_getset = { _wrap_Descriptor_numMips_get, _wrap_Descriptor_numMips_set };
static SwigPyGetSet Descriptor_textureType_getset = { _wrap_Descriptor_textureType_get, _wrap_Descriptor_textureType_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__Descriptor_getset[] = {
    { (char *) "minLODClamp", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The clamp applied to the minimum LOD by the resource view, separate and in addition to\n"
		"any clamp by a sampler used.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &Descriptor_minLODClamp_getset }
,
    { (char *) "swizzle", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The swizzle applied to texture descriptors.\n"
		"\n"
		":type: TextureSwizzle4\n"
		"\n"
		"", (void *) &Descriptor_swizzle_getset }
,
    { (char *) "firstMip", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For texture descriptors, the first mip in the texture which is visible to the\n"
		"descriptor\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Descriptor_firstMip_getset }
,
    { (char *) "view", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The view object used to create this descriptor, which formats or subsets the\n"
		"bound resource referenced by :data:`resource`.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &Descriptor_view_getset }
,
    { (char *) "format", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The format cast that the view uses, for typed buffer and image descriptors.\n"
		"\n"
		":type: ResourceFormat\n"
		"\n"
		"", (void *) &Descriptor_format_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"Descriptor.__dict__", (void *) &Descriptor___dict___getset }
,
    { (char *) "numSlices", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For texture descriptors, the number of slices in a 3D or array texture which are visible\n"
		"to the descriptor\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Descriptor_numSlices_getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For any kind of buffer descriptor, the base byte offset within the resource where the\n"
		"referenced range by the descriptor begins.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Descriptor_byteOffset_getset }
,
    { (char *) "counterByteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset in :data:`secondary` where the counter is stored, for buffer\n"
		"descriptors with a secondary counter.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Descriptor_counterByteOffset_getset }
,
    { (char *) "bufferStructCount", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If the view has a hidden counter, this stores the current value of the counter.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Descriptor_bufferStructCount_getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The type of this descriptor as a general category.\n"
		"\n"
		":type: DescriptorType\n"
		"\n"
		"", (void *) &Descriptor_type_getset }
,
    { (char *) "flags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The flags for additional API-specific and generally non-semantically impactful\n"
		"properties.\n"
		"\n"
		":type: DescriptorFlags\n"
		"\n"
		"", (void *) &Descriptor_flags_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For any kind of buffer descriptor, the number of bytes in the range covered by the\n"
		"descriptor.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Descriptor_byteSize_getset }
,
    { (char *) "elementByteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte size of a single element in the view. Either the byte size of\n"
		":data:`viewFormat`, or the structured buffer element size, as appropriate.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Descriptor_elementByteSize_getset }
,
    { (char *) "firstSlice", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For texture descriptors, the first slice in a 3D or array texture which is visible\n"
		"to the descriptor\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Descriptor_firstSlice_getset }
,
    { (char *) "resource", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The primary bound resource at this descriptor, either a buffer or an image resource.\n"
		"\n"
		"Note that sampler descriptors will not be listed here, see :data:`secondary`.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &Descriptor_resource_getset }
,
    { (char *) "secondary", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The secondary bound resource at this descriptor.\n"
		"\n"
		"For any descriptor containing a sampler, this will be the sampler. For buffer descriptors with an\n"
		"associated counter buffer this will be the counter buffer.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &Descriptor_secondary_getset }
,
    { (char *) "numMips", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For texture descriptors, the number of mips in the texture which are visible to the\n"
		"descriptor\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Descriptor_numMips_getset }
,
    { (char *) "textureType", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The specific type of a texture descriptor.\n"
		"\n"
		":type: TextureType\n"
		"\n"
		"", (void *) &Descriptor_textureType_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__Descriptor_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_Descriptor___eq__(self, other); break;
    case Py_LT : result = _wrap_Descriptor___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__Descriptor_methods[] = {
  { "__eq__", (PyCFunction) _wrap_Descriptor___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_Descriptor___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__Descriptor_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.Descriptor",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_Descriptor_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__Descriptor_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__Descriptor_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__Descriptor_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__Descriptor_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The contents of a descriptor. Not all contents will be valid depending on API and\n"
		"descriptor type, others will be set to sensible defaults.\n"
		"\n"
		"For sampler descriptors, the sampler-specific data can be queried separately and returned as\n"
		":class:`SamplerDescriptor` for sampler types.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__Descriptor_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__Descriptor_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__Descriptor_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_Descriptor,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__Descriptor_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__Descriptor_type};

static SwigPyGetSet SamplerDescriptor_borderColorValue_getset = { _wrap_SamplerDescriptor_borderColorValue_get, _wrap_SamplerDescriptor_borderColorValue_set };
static SwigPyGetSet SamplerDescriptor_creationTimeConstant_getset = { _wrap_SamplerDescriptor_creationTimeConstant_get, _wrap_SamplerDescriptor_creationTimeConstant_set };
static SwigPyGetSet SamplerDescriptor_unnormalized_getset = { _wrap_SamplerDescriptor_unnormalized_get, _wrap_SamplerDescriptor_unnormalized_set };
static SwigPyGetSet SamplerDescriptor_swizzle_getset = { _wrap_SamplerDescriptor_swizzle_get, _wrap_SamplerDescriptor_swizzle_set };
static SwigPyGetSet SamplerDescriptor_ycbcrSampler_getset = { _wrap_SamplerDescriptor_ycbcrSampler_get, _wrap_SamplerDescriptor_ycbcrSampler_set };
static SwigPyGetSet SamplerDescriptor_compareFunction_getset = { _wrap_SamplerDescriptor_compareFunction_get, _wrap_SamplerDescriptor_compareFunction_set };
static SwigPyGetSet SamplerDescriptor_maxAnisotropy_getset = { _wrap_SamplerDescriptor_maxAnisotropy_get, _wrap_SamplerDescriptor_maxAnisotropy_set };
static SwigPyGetSet SamplerDescriptor_ycbcrModel_getset = { _wrap_SamplerDescriptor_ycbcrModel_get, _wrap_SamplerDescriptor_ycbcrModel_set };
static SwigPyGetSet SamplerDescriptor_ycbcrRange_getset = { _wrap_SamplerDescriptor_ycbcrRange_get, _wrap_SamplerDescriptor_ycbcrRange_set };
static SwigPyGetSet SamplerDescriptor___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet SamplerDescriptor_srgbBorder_getset = { _wrap_SamplerDescriptor_srgbBorder_get, _wrap_SamplerDescriptor_srgbBorder_set };
static SwigPyGetSet SamplerDescriptor_seamlessCubemaps_getset = { _wrap_SamplerDescriptor_seamlessCubemaps_get, _wrap_SamplerDescriptor_seamlessCubemaps_set };
static SwigPyGetSet SamplerDescriptor_mipBias_getset = { _wrap_SamplerDescriptor_mipBias_get, _wrap_SamplerDescriptor_mipBias_set };
static SwigPyGetSet SamplerDescriptor_addressU_getset = { _wrap_SamplerDescriptor_addressU_get, _wrap_SamplerDescriptor_addressU_set };
static SwigPyGetSet SamplerDescriptor_borderColorType_getset = { _wrap_SamplerDescriptor_borderColorType_get, _wrap_SamplerDescriptor_borderColorType_set };
static SwigPyGetSet SamplerDescriptor_xChromaOffset_getset = { _wrap_SamplerDescriptor_xChromaOffset_get, _wrap_SamplerDescriptor_xChromaOffset_set };
static SwigPyGetSet SamplerDescriptor_yChromaOffset_getset = { _wrap_SamplerDescriptor_yChromaOffset_get, _wrap_SamplerDescriptor_yChromaOffset_set };
static SwigPyGetSet SamplerDescriptor_addressV_getset = { _wrap_SamplerDescriptor_addressV_get, _wrap_SamplerDescriptor_addressV_set };
static SwigPyGetSet SamplerDescriptor_filter_getset = { _wrap_SamplerDescriptor_filter_get, _wrap_SamplerDescriptor_filter_set };
static SwigPyGetSet SamplerDescriptor_chromaFilter_getset = { _wrap_SamplerDescriptor_chromaFilter_get, _wrap_SamplerDescriptor_chromaFilter_set };
static SwigPyGetSet SamplerDescriptor_type_getset = { _wrap_SamplerDescriptor_type_get, _wrap_SamplerDescriptor_type_set };
static SwigPyGetSet SamplerDescriptor_addressW_getset = { _wrap_SamplerDescriptor_addressW_get, _wrap_SamplerDescriptor_addressW_set };
static SwigPyGetSet SamplerDescriptor_maxLOD_getset = { _wrap_SamplerDescriptor_maxLOD_get, _wrap_SamplerDescriptor_maxLOD_set };
static SwigPyGetSet SamplerDescriptor_object_getset = { _wrap_SamplerDescriptor_object_get, _wrap_SamplerDescriptor_object_set };
static SwigPyGetSet SamplerDescriptor_minLOD_getset = { _wrap_SamplerDescriptor_minLOD_get, _wrap_SamplerDescriptor_minLOD_set };
static SwigPyGetSet SamplerDescriptor_forceExplicitReconstruction_getset = { _wrap_SamplerDescriptor_forceExplicitReconstruction_get, _wrap_SamplerDescriptor_forceExplicitReconstruction_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SamplerDescriptor_getset[] = {
    { (char *) "borderColorValue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The RGBA border color value. Typically the float tuple inside will be used,\n"
		"but the exact component type can be checked with :data:`borderColorType`.\n"
		"\n"
		":type: PixelValue\n"
		"\n"
		"", (void *) &SamplerDescriptor_borderColorValue_getset }
,
    { (char *) "creationTimeConstant", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this sampler was initialised at creation time for a pipeline or\n"
		"descriptor layout, the method being API specific. If so this sampler is not dynamic and was not\n"
		"explicitly set and may have no real descriptor storage.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &SamplerDescriptor_creationTimeConstant_getset }
,
    { (char *) "unnormalized", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if unnormalized co-ordinates are used in this sampler.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &SamplerDescriptor_unnormalized_getset }
,
    { (char *) "swizzle", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The swizzle applied. Primarily for ycbcr samplers applied before\n"
		"conversion but for non-ycbcr samplers can be used for implementations that require sampler swizzle\n"
		"information for border colors.\n"
		"\n"
		":type: TextureSwizzle4\n"
		"\n"
		"", (void *) &SamplerDescriptor_swizzle_getset }
,
    { (char *) "ycbcrSampler", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the ycbcr conversion object associated with\n"
		"this sampler.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &SamplerDescriptor_ycbcrSampler_getset }
,
    { (char *) "compareFunction", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`CompareFunction` for comparison samplers.\n"
		"\n"
		":type: CompareFunction\n"
		"\n"
		"", (void *) &SamplerDescriptor_compareFunction_getset }
,
    { (char *) "maxAnisotropy", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The maximum anisotropic filtering level to use.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &SamplerDescriptor_maxAnisotropy_getset }
,
    { (char *) "ycbcrModel", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For ycbcr samplers - the :class:`YcbcrConversion` used for conversion.\n"
		"\n"
		":type: YcbcrConversion\n"
		"\n"
		"", (void *) &SamplerDescriptor_ycbcrModel_getset }
,
    { (char *) "ycbcrRange", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For ycbcr samplers - the :class:`YcbcrRange` used for conversion.\n"
		"\n"
		":type: YcbcrRange\n"
		"\n"
		"", (void *) &SamplerDescriptor_ycbcrRange_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SamplerDescriptor.__dict__", (void *) &SamplerDescriptor___dict___getset }
,
    { (char *) "srgbBorder", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the border colour is swizzled with an sRGB formatted image.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &SamplerDescriptor_srgbBorder_getset }
,
    { (char *) "seamlessCubemaps", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this sampler is seamless across cubemap boundaries (the default).\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &SamplerDescriptor_seamlessCubemaps_getset }
,
    { (char *) "mipBias", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A bias to apply to the calculated mip level before sampling.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &SamplerDescriptor_mipBias_getset }
,
    { (char *) "addressU", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`AddressMode` in the U direction.\n"
		"\n"
		":type: AddressMode\n"
		"\n"
		"", (void *) &SamplerDescriptor_addressU_getset }
,
    { (char *) "borderColorType", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The RGBA border color type. This determines how the data in\n"
		":data:`borderColorValue` will be interpreted.\n"
		"\n"
		":type: CompType\n"
		"\n"
		"", (void *) &SamplerDescriptor_borderColorType_getset }
,
    { (char *) "xChromaOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For ycbcr samplers - the :class:`ChromaSampleLocation` X-axis chroma offset.\n"
		"\n"
		":type: ChromaSampleLocation\n"
		"\n"
		"", (void *) &SamplerDescriptor_xChromaOffset_getset }
,
    { (char *) "yChromaOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For ycbcr samplers - the :class:`ChromaSampleLocation` Y-axis chroma offset.\n"
		"\n"
		":type: ChromaSampleLocation\n"
		"\n"
		"", (void *) &SamplerDescriptor_yChromaOffset_getset }
,
    { (char *) "addressV", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`AddressMode` in the V direction.\n"
		"\n"
		":type: AddressMode\n"
		"\n"
		"", (void *) &SamplerDescriptor_addressV_getset }
,
    { (char *) "filter", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The filtering mode.\n"
		"\n"
		":type: TextureFilter\n"
		"\n"
		"", (void *) &SamplerDescriptor_filter_getset }
,
    { (char *) "chromaFilter", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For ycbcr samplers - the :class:`FilterMode` describing the chroma filtering mode.\n"
		"\n"
		":type: FilterMode\n"
		"\n"
		"", (void *) &SamplerDescriptor_chromaFilter_getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The type of this descriptor as a general category.\n"
		"\n"
		"If this is not set to :data:`DescriptorType.Sampler` or :data:`DescriptorType.ImageSampler` the rest\n"
		"of the contents of this structure are not valid as the descriptor is not a sampler descriptor.\n"
		"\n"
		":type: DescriptorType\n"
		"\n"
		"", (void *) &SamplerDescriptor_type_getset }
,
    { (char *) "addressW", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`AddressMode` in the W direction.\n"
		"\n"
		":type: AddressMode\n"
		"\n"
		"", (void *) &SamplerDescriptor_addressW_getset }
,
    { (char *) "maxLOD", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The maximum mip level that can be used.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &SamplerDescriptor_maxLOD_getset }
,
    { (char *) "object", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For APIs where samplers are an explicit object, the :class:`ResourceId` of the sampler\n"
		"itself\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &SamplerDescriptor_object_getset }
,
    { (char *) "minLOD", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The minimum mip level that can be used.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &SamplerDescriptor_minLOD_getset }
,
    { (char *) "forceExplicitReconstruction", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For ycbcr samplers - ``True`` if explicit reconstruction is force enabled.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &SamplerDescriptor_forceExplicitReconstruction_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SamplerDescriptor_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_SamplerDescriptor___eq__(self, other); break;
    case Py_LT : result = _wrap_SamplerDescriptor___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SamplerDescriptor_methods[] = {
  { "__eq__", (PyCFunction) _wrap_SamplerDescriptor___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_SamplerDescriptor___lt__, METH_O, (char *) "__lt__(o)" },
  { "UseBorder", (PyCFunction) _wrap_SamplerDescriptor_UseBorder, METH_NOARGS, (char *) "\n"
		"UseBorder()\n"
		"\n"
		"Check if the border color is used in this D3D11 sampler.\n"
		"\n"
		":return: ``True`` if the border color is used, ``False`` otherwise.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SamplerDescriptor_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.SamplerDescriptor",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_SamplerDescriptor_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SamplerDescriptor_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__SamplerDescriptor_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__SamplerDescriptor_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SamplerDescriptor_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The contents of a sampler descriptor. Not all contents will be valid depending on API\n"
		"and capabilities, others will be set to sensible defaults.\n"
		"\n"
		"For normal descriptors, the resource data should be queried and returned in :class:`Descriptor`.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SamplerDescriptor_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SamplerDescriptor_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SamplerDescriptor_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_SamplerDescriptor,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SamplerDescriptor_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SamplerDescriptor_type};

static SwigPyGetSet DescriptorAccess_stage_getset = { _wrap_DescriptorAccess_stage_get, _wrap_DescriptorAccess_stage_set };
static SwigPyGetSet DescriptorAccess_descriptorStore_getset = { _wrap_DescriptorAccess_descriptorStore_get, _wrap_DescriptorAccess_descriptorStore_set };
static SwigPyGetSet DescriptorAccess___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet DescriptorAccess_byteOffset_getset = { _wrap_DescriptorAccess_byteOffset_get, _wrap_DescriptorAccess_byteOffset_set };
static SwigPyGetSet DescriptorAccess_type_getset = { _wrap_DescriptorAccess_type_get, _wrap_DescriptorAccess_type_set };
static SwigPyGetSet DescriptorAccess_byteSize_getset = { _wrap_DescriptorAccess_byteSize_get, _wrap_DescriptorAccess_byteSize_set };
static SwigPyGetSet DescriptorAccess_index_getset = { _wrap_DescriptorAccess_index_get, _wrap_DescriptorAccess_index_set };
static SwigPyGetSet DescriptorAccess_staticallyUnused_getset = { _wrap_DescriptorAccess_staticallyUnused_get, _wrap_DescriptorAccess_staticallyUnused_set };
static SwigPyGetSet DescriptorAccess_arrayElement_getset = { _wrap_DescriptorAccess_arrayElement_get, _wrap_DescriptorAccess_arrayElement_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DescriptorAccess_getset[] = {
    { (char *) "stage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The shader stage that this descriptor access came from.\n"
		"\n"
		":type: ShaderStage\n"
		"\n"
		"", (void *) &DescriptorAccess_stage_getset }
,
    { (char *) "descriptorStore", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The backing storage of the descriptor.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &DescriptorAccess_descriptorStore_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DescriptorAccess.__dict__", (void *) &DescriptorAccess___dict___getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in bytes to the descriptor in the descriptor store.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DescriptorAccess_byteOffset_getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The type of the descriptor being accessed.\n"
		"\n"
		":type: DescriptorType\n"
		"\n"
		"", (void *) &DescriptorAccess_type_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size in bytes of the descriptor.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DescriptorAccess_byteSize_getset }
,
    { (char *) "index", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index within the shader's reflection list corresponding to :data:`type` of the\n"
		"accessing resource.\n"
		"\n"
		"If this value is set to :data:`NoShaderBinding` then the shader synthesised a direct access into\n"
		"descriptor storage without passing through a declared binding.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DescriptorAccess_index_getset }
,
    { (char *) "staticallyUnused", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For informational purposes, some descriptors that are declared in the shader\n"
		"interface but are provably unused may still be reported as descriptor accesses. This flag will be\n"
		"set to ``True`` to indicate that the descriptor was definitely not used.\n"
		"\n"
		"This flag only states that a descriptor is definitely unused on all paths. If set to ``False`` this\n"
		"does not necessarily guarantee that the descriptor was accessed on the GPU during execution.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &DescriptorAccess_staticallyUnused_getset }
,
    { (char *) "arrayElement", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For an arrayed resource declared in a shader, the array element used.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DescriptorAccess_arrayElement_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DescriptorAccess_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_DescriptorAccess___eq__(self, other); break;
    case Py_LT : result = _wrap_DescriptorAccess___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DescriptorAccess_methods[] = {
  { "__eq__", (PyCFunction) _wrap_DescriptorAccess___eq__, METH_VARARGS, (char *) "\n"
		"__eq__(o)\n"
		"__eq__(o)\n"
		"__eq__(o)\n"
		"" },
  { "__lt__", (PyCFunction) _wrap_DescriptorAccess___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DescriptorAccess_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.DescriptorAccess",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DescriptorAccess_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DescriptorAccess_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__DescriptorAccess_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__DescriptorAccess_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DescriptorAccess_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The details of a single accessed descriptor as fetched by a shader and which descriptor\n"
		"in the descriptor store was fetched.\n"
		"\n"
		"This may be a somewhat conservative access, reported as possible but not actually executed on the\n"
		"GPU itself.\n"
		"\n"
		".. data:: NoShaderBinding\n"
		"\n"
		"  No shader binding corresponds to this descriptor access, it happened directly without going\n"
		"  through any kind of binding.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DescriptorAccess_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DescriptorAccess_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DescriptorAccess_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DescriptorAccess,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DescriptorAccess_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DescriptorAccess_type};

static SwigPyGetSet DescriptorLogicalLocation_logicalBindName_getset = { _wrap_DescriptorLogicalLocation_logicalBindName_get, _wrap_DescriptorLogicalLocation_logicalBindName_set };
static SwigPyGetSet DescriptorLogicalLocation_stageMask_getset = { _wrap_DescriptorLogicalLocation_stageMask_get, _wrap_DescriptorLogicalLocation_stageMask_set };
static SwigPyGetSet DescriptorLogicalLocation_fixedBindNumber_getset = { _wrap_DescriptorLogicalLocation_fixedBindNumber_get, _wrap_DescriptorLogicalLocation_fixedBindNumber_set };
static SwigPyGetSet DescriptorLogicalLocation___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet DescriptorLogicalLocation_category_getset = { _wrap_DescriptorLogicalLocation_category_get, _wrap_DescriptorLogicalLocation_category_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DescriptorLogicalLocation_getset[] = {
    { (char *) "logicalBindName", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The logical binding name, as suitable for displaying to a user when displaying\n"
		"the contents of a descriptor queried directly from a heap.\n"
		"\n"
		"Depending on the API, this name may be identical or less specific than the one obtained from\n"
		"shader reflection. Generally speaking it's preferred to use any information from shader reflection\n"
		"first, and fall back to this name if no reflection information is available in the context.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &DescriptorLogicalLocation_logicalBindName_getset }
,
    { (char *) "stageMask", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The set of shader stages that this descriptor is intrinsically available to. This is\n"
		"primarily relevant for D3D11 with its fixed per-stage register binding points.\n"
		"\n"
		"Note this *only* shows if a descriptor itself can only ever be accessed by some shader stages by\n"
		"definition, not if a descriptor is generally available but happened to only be accessed by one or\n"
		"more stage. That information is available directly in the :class:`DescriptorAccess` itself.\n"
		"\n"
		":type: ShaderStageMask\n"
		"\n"
		"", (void *) &DescriptorLogicalLocation_stageMask_getset }
,
    { (char *) "fixedBindNumber", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed binding number for this descriptor. The interpretation of this is\n"
		"API-specific and it is provided purely for informational purposes and has no bearing on how data\n"
		"is accessed or described.\n"
		"\n"
		"Generally speaking sorting by this number will give a reasonable ordering by binding if it exists.\n"
		"\n"
		".. note::\n"
		"  Because this number is API-specific, there is no guarantee that it will be unique across all\n"
		"  descriptors. It should be used only within contexts that can interpret it API-specifically, or\n"
		"  else for purely informational/non-semantic purposes like sorting.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DescriptorLogicalLocation_fixedBindNumber_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DescriptorLogicalLocation.__dict__", (void *) &DescriptorLogicalLocation___dict___getset }
,
    { (char *) "category", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The general category of a descriptor stored. This may not be available for\n"
		"uninitialised descriptors on all APIs.\n"
		"\n"
		":type: DescriptorCategory\n"
		"\n"
		"", (void *) &DescriptorLogicalLocation_category_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DescriptorLogicalLocation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_DescriptorLogicalLocation___eq__(self, other); break;
    case Py_LT : result = _wrap_DescriptorLogicalLocation___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DescriptorLogicalLocation_methods[] = {
  { "__eq__", (PyCFunction) _wrap_DescriptorLogicalLocation___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_DescriptorLogicalLocation___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DescriptorLogicalLocation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.DescriptorLogicalLocation",    /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DescriptorLogicalLocation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DescriptorLogicalLocation_type.as_number,     /* tp_as_number */
    &SwigPyBuiltin__DescriptorLogicalLocation_type.as_sequence,   /* tp_as_sequence */
    &SwigPyBuiltin__DescriptorLogicalLocation_type.as_mapping,    /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DescriptorLogicalLocation_type.as_buffer,     /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"In many cases there may be a logical location or fixed binding point for a particular\n"
		"descriptor which is not conveyed with a simple byte offset into a descriptor store.\n"
		"This is particularly true for any descriptor stores that are not equivalent to a buffer of bytes\n"
		"but actually have an API structure - for example D3D11 and GL with fixed binding points, or Vulkan\n"
		"with descriptor sets.\n"
		"\n"
		"In some cases on APIs with explicit descriptor storage this may convey information about virtualised\n"
		"descriptors that are not explicitly backed with real storage.\n"
		"\n"
		"This structure describes such a location queried for a given descriptor.\n"
		"\n"
		"For example on D3D11 this would give the register number of the binding, and on GL it would give the\n"
		"unit index. Both cases would be able to query the type and shader stage visibility of descriptors\n"
		"that are not accessed or even bound.\n"
		"\n"
		"On Vulkan this would give the set, binding, and visibility. In most cases this information will be\n"
		"available for all descriptors but in some cases the type of descriptor may not be available if it\n"
		"is unused and has not been initialised.\n"
		"\n"
		"On D3D12 this would only give the index into the heap, as no other information is available purely\n"
		"by the descriptor itself.\n"
		"\n"
		".. note::\n"
		"\n"
		"  This information may not be fully present on all APIs so the returned structures may be empty or\n"
		"  partially filled out, depending on what information is relevant per API.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DescriptorLogicalLocation_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DescriptorLogicalLocation_methods,             /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DescriptorLogicalLocation_getset,              /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DescriptorLogicalLocation,               /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DescriptorLogicalLocation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DescriptorLogicalLocation_type};

static SwigPyGetSet UsedDescriptor_descriptor_getset = { _wrap_UsedDescriptor_descriptor_get, _wrap_UsedDescriptor_descriptor_set };
static SwigPyGetSet UsedDescriptor_sampler_getset = { _wrap_UsedDescriptor_sampler_get, _wrap_UsedDescriptor_sampler_set };
static SwigPyGetSet UsedDescriptor___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet UsedDescriptor_access_getset = { _wrap_UsedDescriptor_access_get, _wrap_UsedDescriptor_access_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__UsedDescriptor_getset[] = {
    { (char *) "descriptor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The contents of the accessed descriptor, if it is a normal non-sampler descriptor.\n"
		"\n"
		"For sampler descriptors this is empty.\n"
		"\n"
		":type: Descriptor\n"
		"\n"
		"", (void *) &UsedDescriptor_descriptor_getset }
,
    { (char *) "sampler", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The contents of the accessed descriptor, if it is a sampler descriptor.\n"
		"\n"
		"For normal descriptors this is empty.\n"
		"\n"
		":type: SamplerDescriptor\n"
		"\n"
		"", (void *) &UsedDescriptor_sampler_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"UsedDescriptor.__dict__", (void *) &UsedDescriptor___dict___getset }
,
    { (char *) "access", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The access information of which shader reflection object accessed which descriptor.\n"
		"\n"
		":type: DescriptorAccess\n"
		"\n"
		"", (void *) &UsedDescriptor_access_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__UsedDescriptor_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_UsedDescriptor___eq__(self, other); break;
    case Py_LT : result = _wrap_UsedDescriptor___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__UsedDescriptor_methods[] = {
  { "__eq__", (PyCFunction) _wrap_UsedDescriptor___eq__, METH_VARARGS, (char *) "\n"
		"__eq__(o)\n"
		"__eq__(o)\n"
		"__eq__(o)\n"
		"__eq__(o)\n"
		"" },
  { "__lt__", (PyCFunction) _wrap_UsedDescriptor___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__UsedDescriptor_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.UsedDescriptor",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_UsedDescriptor_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__UsedDescriptor_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__UsedDescriptor_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__UsedDescriptor_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__UsedDescriptor_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Combined information about a single descriptor that has been used, both the information\n"
		"about its access and its contents.\n"
		"\n"
		"This is a helper struct for the common pipeline state abstraction to trade off simplicity of access\n"
		"against optimal access.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__UsedDescriptor_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__UsedDescriptor_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__UsedDescriptor_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_UsedDescriptor,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__UsedDescriptor_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__UsedDescriptor_type};

static SwigPyGetSet Offset_x_getset = { _wrap_Offset_x_get, _wrap_Offset_x_set };
static SwigPyGetSet Offset_y_getset = { _wrap_Offset_y_get, _wrap_Offset_y_set };
static SwigPyGetSet Offset___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__Offset_getset[] = {
    { (char *) "x", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The X offset value.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Offset_x_getset }
,
    { (char *) "y", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The Y offset value.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Offset_y_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"Offset.__dict__", (void *) &Offset___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__Offset_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_Offset___eq__(self, other); break;
    case Py_LT : result = _wrap_Offset___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__Offset_methods[] = {
  { "__eq__", (PyCFunction) _wrap_Offset___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_Offset___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__Offset_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.Offset",                       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_Offset_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__Offset_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__Offset_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__Offset_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__Offset_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a 2-dimensional int offset",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__Offset_richcompare,              /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__Offset_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__Offset_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_Offset,              /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__Offset_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__Offset_type};

static SwigPyGetSet VertexInputAttribute_used_getset = { _wrap_VertexInputAttribute_used_get, _wrap_VertexInputAttribute_used_set };
static SwigPyGetSet VertexInputAttribute_name_getset = { _wrap_VertexInputAttribute_name_get, _wrap_VertexInputAttribute_name_set };
static SwigPyGetSet VertexInputAttribute_vertexBuffer_getset = { _wrap_VertexInputAttribute_vertexBuffer_get, _wrap_VertexInputAttribute_vertexBuffer_set };
static SwigPyGetSet VertexInputAttribute_genericValue_getset = { _wrap_VertexInputAttribute_genericValue_get, _wrap_VertexInputAttribute_genericValue_set };
static SwigPyGetSet VertexInputAttribute_genericEnabled_getset = { _wrap_VertexInputAttribute_genericEnabled_get, _wrap_VertexInputAttribute_genericEnabled_set };
static SwigPyGetSet VertexInputAttribute_format_getset = { _wrap_VertexInputAttribute_format_get, _wrap_VertexInputAttribute_format_set };
static SwigPyGetSet VertexInputAttribute___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VertexInputAttribute_byteOffset_getset = { _wrap_VertexInputAttribute_byteOffset_get, _wrap_VertexInputAttribute_byteOffset_set };
static SwigPyGetSet VertexInputAttribute_perInstance_getset = { _wrap_VertexInputAttribute_perInstance_get, _wrap_VertexInputAttribute_perInstance_set };
static SwigPyGetSet VertexInputAttribute_instanceRate_getset = { _wrap_VertexInputAttribute_instanceRate_get, _wrap_VertexInputAttribute_instanceRate_set };
static SwigPyGetSet VertexInputAttribute_floatCastWrong_getset = { _wrap_VertexInputAttribute_floatCastWrong_get, _wrap_VertexInputAttribute_floatCastWrong_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VertexInputAttribute_getset[] = {
    { (char *) "used", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this attribute is enabled and used by the vertex shader.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VertexInputAttribute_used_getset }
,
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of this input. This may be a variable name or a semantic name.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &VertexInputAttribute_name_getset }
,
    { (char *) "vertexBuffer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index of the vertex buffer used to provide this attribute.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VertexInputAttribute_vertexBuffer_getset }
,
    { (char *) "genericValue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The generic value for this attribute if it has no vertex buffer bound.\n"
		"\n"
		":type: PixelValue\n"
		"\n"
		"", (void *) &VertexInputAttribute_genericValue_getset }
,
    { (char *) "genericEnabled", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this attribute is using :data:`genericValue` for its data.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VertexInputAttribute_genericEnabled_getset }
,
    { (char *) "format", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The interpreted format of this attribute.\n"
		"\n"
		":type: ResourceFormat\n"
		"\n"
		"", (void *) &VertexInputAttribute_format_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VertexInputAttribute.__dict__", (void *) &VertexInputAttribute___dict___getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset from the start of the vertex data for this VB to this attribute.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VertexInputAttribute_byteOffset_getset }
,
    { (char *) "perInstance", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this attribute runs at instance rate.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VertexInputAttribute_perInstance_getset }
,
    { (char *) "instanceRate", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If :data:`perInstance` is ``True``, the number of instances that source the same value\n"
		"from the vertex buffer before advancing to the next value.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VertexInputAttribute_instanceRate_getset }
,
    { (char *) "floatCastWrong", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Only valid for attributes on OpenGL. If the attribute has been set up for integers to\n"
		"be converted to floats (glVertexAttribFormat with GL_INT) we store the format as integers. This is\n"
		"fine if the application has a float input in the shader it just means we display the raw integer\n"
		"instead of the casted float. However if the shader has an integer input this is invalid and it will\n"
		"read something undefined - possibly the int bits of the casted float.\n"
		"\n"
		"This property is set to ``True`` if the cast happens to an integer input and that bad cast needs to\n"
		"be emulated.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VertexInputAttribute_floatCastWrong_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VertexInputAttribute_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_VertexInputAttribute___eq__(self, other); break;
    case Py_LT : result = _wrap_VertexInputAttribute___lt__(self, other); break;
    case Py_NE : result = _wrap_VertexInputAttribute___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VertexInputAttribute_methods[] = {
  { "__lt__", (PyCFunction) _wrap_VertexInputAttribute___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_VertexInputAttribute___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_VertexInputAttribute___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VertexInputAttribute_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VertexInputAttribute",         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VertexInputAttribute_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VertexInputAttribute_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__VertexInputAttribute_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__VertexInputAttribute_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VertexInputAttribute_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Information about a vertex input attribute feeding the vertex shader.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VertexInputAttribute_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VertexInputAttribute_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VertexInputAttribute_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VertexInputAttribute,/* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VertexInputAttribute_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VertexInputAttribute_type};

static SwigPyGetSet ShaderMeshMessageLocation_meshGroup_getset = { _wrap_ShaderMeshMessageLocation_meshGroup_get, _wrap_ShaderMeshMessageLocation_meshGroup_set };
static SwigPyGetSet ShaderMeshMessageLocation___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderMeshMessageLocation_taskGroup_getset = { _wrap_ShaderMeshMessageLocation_taskGroup_get, _wrap_ShaderMeshMessageLocation_taskGroup_set };
static SwigPyGetSet ShaderMeshMessageLocation_thread_getset = { _wrap_ShaderMeshMessageLocation_thread_get, _wrap_ShaderMeshMessageLocation_thread_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderMeshMessageLocation_getset[] = {
    { (char *) "meshGroup", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The mesh workgroup index within the dispatch or launching task workgroup.\n"
		"\n"
		":type: Tuple[int,int,int]\n"
		"\n"
		"", (void *) &ShaderMeshMessageLocation_meshGroup_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderMeshMessageLocation.__dict__", (void *) &ShaderMeshMessageLocation___dict___getset }
,
    { (char *) "taskGroup", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The task workgroup index between the task dispatch.\n"
		"\n"
		".. note::\n"
		"  If no task shader is in use, this will be :data:`NotUsed`, :data:`NotUsed`, :data:`NotUsed`.\n"
		"\n"
		":type: Tuple[int,int,int]\n"
		"\n"
		"", (void *) &ShaderMeshMessageLocation_taskGroup_getset }
,
    { (char *) "thread", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The thread index within the workgroup, either for a task shader or mesh shader.\n"
		"\n"
		".. note::\n"
		"  Since task shaders can only emit one set of meshes per group, the task thread is not relevant\n"
		"  for mesh shader messages, so this is the thread either for a task or a mesh shader message.\n"
		"\n"
		":type: Tuple[int,int,int]\n"
		"\n"
		"", (void *) &ShaderMeshMessageLocation_thread_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderMeshMessageLocation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderMeshMessageLocation___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderMeshMessageLocation___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderMeshMessageLocation_methods[] = {
  { "__eq__", (PyCFunction) _wrap_ShaderMeshMessageLocation___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_ShaderMeshMessageLocation___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderMeshMessageLocation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderMeshMessageLocation",    /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderMeshMessageLocation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderMeshMessageLocation_type.as_number,     /* tp_as_number */
    &SwigPyBuiltin__ShaderMeshMessageLocation_type.as_sequence,   /* tp_as_sequence */
    &SwigPyBuiltin__ShaderMeshMessageLocation_type.as_mapping,    /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderMeshMessageLocation_type.as_buffer,     /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A task or mesh message's location.\n"
		"\n"
		".. data:: NotUsed\n"
		"\n"
		"  Set for values of task group/thread index when no task shaders were run.\n"
		"\n"
		"  Also set for values of a mesh group or thread index when that dimensionality is unused. For\n"
		"  example if the shader declares a group dimension of (128,1,1) then the y and z values for\n"
		"  thread index will be indicated as not used.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderMeshMessageLocation_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderMeshMessageLocation_methods,             /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderMeshMessageLocation_getset,              /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderMeshMessageLocation,               /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderMeshMessageLocation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderMeshMessageLocation_type};

static SwigPyGetSet ShaderComputeMessageLocation_workgroup_getset = { _wrap_ShaderComputeMessageLocation_workgroup_get, _wrap_ShaderComputeMessageLocation_workgroup_set };
static SwigPyGetSet ShaderComputeMessageLocation___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderComputeMessageLocation_thread_getset = { _wrap_ShaderComputeMessageLocation_thread_get, _wrap_ShaderComputeMessageLocation_thread_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderComputeMessageLocation_getset[] = {
    { (char *) "workgroup", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The workgroup index within the dispatch.\n"
		"\n"
		":type: Tuple[int,int,int]\n"
		"\n"
		"", (void *) &ShaderComputeMessageLocation_workgroup_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderComputeMessageLocation.__dict__", (void *) &ShaderComputeMessageLocation___dict___getset }
,
    { (char *) "thread", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The thread index within the workgroup.\n"
		"\n"
		":type: Tuple[int,int,int]\n"
		"\n"
		"", (void *) &ShaderComputeMessageLocation_thread_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderComputeMessageLocation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderComputeMessageLocation___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderComputeMessageLocation___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderComputeMessageLocation_methods[] = {
  { "__eq__", (PyCFunction) _wrap_ShaderComputeMessageLocation___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_ShaderComputeMessageLocation___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderComputeMessageLocation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderComputeMessageLocation", /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderComputeMessageLocation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderComputeMessageLocation_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__ShaderComputeMessageLocation_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__ShaderComputeMessageLocation_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderComputeMessageLocation_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A compute shader message's location.",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderComputeMessageLocation_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderComputeMessageLocation_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderComputeMessageLocation_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderComputeMessageLocation,            /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderComputeMessageLocation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderComputeMessageLocation_type};

static SwigPyGetSet ShaderVertexMessageLocation_view_getset = { _wrap_ShaderVertexMessageLocation_view_get, _wrap_ShaderVertexMessageLocation_view_set };
static SwigPyGetSet ShaderVertexMessageLocation___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderVertexMessageLocation_vertexIndex_getset = { _wrap_ShaderVertexMessageLocation_vertexIndex_get, _wrap_ShaderVertexMessageLocation_vertexIndex_set };
static SwigPyGetSet ShaderVertexMessageLocation_instance_getset = { _wrap_ShaderVertexMessageLocation_instance_get, _wrap_ShaderVertexMessageLocation_instance_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderVertexMessageLocation_getset[] = {
    { (char *) "view", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The multiview view for this vertex, or ``0`` if multiview is disabled.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderVertexMessageLocation_view_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderVertexMessageLocation.__dict__", (void *) &ShaderVertexMessageLocation___dict___getset }
,
    { (char *) "vertexIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex or index for this vertex.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderVertexMessageLocation_vertexIndex_getset }
,
    { (char *) "instance", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The instance for this vertex.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderVertexMessageLocation_instance_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderVertexMessageLocation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderVertexMessageLocation_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderVertexMessageLocation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderVertexMessageLocation",  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderVertexMessageLocation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderVertexMessageLocation_type.as_number,   /* tp_as_number */
    &SwigPyBuiltin__ShaderVertexMessageLocation_type.as_sequence, /* tp_as_sequence */
    &SwigPyBuiltin__ShaderVertexMessageLocation_type.as_mapping,  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderVertexMessageLocation_type.as_buffer,   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A vertex shader message's location.",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderVertexMessageLocation_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderVertexMessageLocation_methods,           /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderVertexMessageLocation_getset,            /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderVertexMessageLocation,             /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderVertexMessageLocation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderVertexMessageLocation_type};

static SwigPyGetSet ShaderPixelMessageLocation_x_getset = { _wrap_ShaderPixelMessageLocation_x_get, _wrap_ShaderPixelMessageLocation_x_set };
static SwigPyGetSet ShaderPixelMessageLocation_y_getset = { _wrap_ShaderPixelMessageLocation_y_get, _wrap_ShaderPixelMessageLocation_y_set };
static SwigPyGetSet ShaderPixelMessageLocation_view_getset = { _wrap_ShaderPixelMessageLocation_view_get, _wrap_ShaderPixelMessageLocation_view_set };
static SwigPyGetSet ShaderPixelMessageLocation___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderPixelMessageLocation_primitive_getset = { _wrap_ShaderPixelMessageLocation_primitive_get, _wrap_ShaderPixelMessageLocation_primitive_set };
static SwigPyGetSet ShaderPixelMessageLocation_sample_getset = { _wrap_ShaderPixelMessageLocation_sample_get, _wrap_ShaderPixelMessageLocation_sample_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderPixelMessageLocation_getset[] = {
    { (char *) "x", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The x co-ordinate of the pixel.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderPixelMessageLocation_x_getset }
,
    { (char *) "y", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The y co-ordinate of the pixel.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderPixelMessageLocation_y_getset }
,
    { (char *) "view", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The multiview view for this fragment, or ``0`` if multiview is disabled.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderPixelMessageLocation_view_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderPixelMessageLocation.__dict__", (void *) &ShaderPixelMessageLocation___dict___getset }
,
    { (char *) "primitive", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The generating primitive, or :data:`NoLocation` if the primitive ID is unavailable.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderPixelMessageLocation_primitive_getset }
,
    { (char *) "sample", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The sample, or :data:`NoLocation` if sample shading is disabled.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderPixelMessageLocation_sample_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderPixelMessageLocation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderPixelMessageLocation_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderPixelMessageLocation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderPixelMessageLocation",   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderPixelMessageLocation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderPixelMessageLocation_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__ShaderPixelMessageLocation_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__ShaderPixelMessageLocation_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderPixelMessageLocation_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A pixel shader message's location.\n"
		"\n"
		".. data:: NoLocation\n"
		"\n"
		"  No frame number is available.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderPixelMessageLocation_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderPixelMessageLocation_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderPixelMessageLocation_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderPixelMessageLocation,              /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderPixelMessageLocation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderPixelMessageLocation_type};

static SwigPyGetSet ShaderGeometryMessageLocation_view_getset = { _wrap_ShaderGeometryMessageLocation_view_get, _wrap_ShaderGeometryMessageLocation_view_set };
static SwigPyGetSet ShaderGeometryMessageLocation___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderGeometryMessageLocation_primitive_getset = { _wrap_ShaderGeometryMessageLocation_primitive_get, _wrap_ShaderGeometryMessageLocation_primitive_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderGeometryMessageLocation_getset[] = {
    { (char *) "view", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The multiview view for this primitive, or ``0`` if multiview is disabled.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderGeometryMessageLocation_view_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderGeometryMessageLocation.__dict__", (void *) &ShaderGeometryMessageLocation___dict___getset }
,
    { (char *) "primitive", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The primitive index\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderGeometryMessageLocation_primitive_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderGeometryMessageLocation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderGeometryMessageLocation_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderGeometryMessageLocation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderGeometryMessageLocation",/* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderGeometryMessageLocation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderGeometryMessageLocation_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__ShaderGeometryMessageLocation_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__ShaderGeometryMessageLocation_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderGeometryMessageLocation_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A geometry shader message's location.\n"
		"\n"
		".. data:: NoLocation\n"
		"\n"
		"  No frame number is available.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderGeometryMessageLocation_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderGeometryMessageLocation_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderGeometryMessageLocation_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderGeometryMessageLocation,           /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderGeometryMessageLocation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderGeometryMessageLocation_type};

static SwigPyGetSet ShaderMessageLocation_mesh_getset = { _wrap_ShaderMessageLocation_mesh_get, _wrap_ShaderMessageLocation_mesh_set };
static SwigPyGetSet ShaderMessageLocation_vertex_getset = { _wrap_ShaderMessageLocation_vertex_get, _wrap_ShaderMessageLocation_vertex_set };
static SwigPyGetSet ShaderMessageLocation___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderMessageLocation_compute_getset = { _wrap_ShaderMessageLocation_compute_get, _wrap_ShaderMessageLocation_compute_set };
static SwigPyGetSet ShaderMessageLocation_pixel_getset = { _wrap_ShaderMessageLocation_pixel_get, _wrap_ShaderMessageLocation_pixel_set };
static SwigPyGetSet ShaderMessageLocation_geometry_getset = { _wrap_ShaderMessageLocation_geometry_get, _wrap_ShaderMessageLocation_geometry_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderMessageLocation_getset[] = {
    { (char *) "mesh", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The location if the shader is a task or mesh shader.\n"
		"\n"
		":type: ShaderMeshMessageLocation\n"
		"\n"
		"", (void *) &ShaderMessageLocation_mesh_getset }
,
    { (char *) "vertex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The location if the shader is a vertex shader.\n"
		"\n"
		":type: ShaderVertexMessageLocation\n"
		"\n"
		"", (void *) &ShaderMessageLocation_vertex_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderMessageLocation.__dict__", (void *) &ShaderMessageLocation___dict___getset }
,
    { (char *) "compute", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The location if the shader is a compute shader.\n"
		"\n"
		":type: ShaderComputeMessageLocation\n"
		"\n"
		"", (void *) &ShaderMessageLocation_compute_getset }
,
    { (char *) "pixel", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The location if the shader is a pixel shader.\n"
		"\n"
		":type: ShaderPixelMessageLocation\n"
		"\n"
		"", (void *) &ShaderMessageLocation_pixel_getset }
,
    { (char *) "geometry", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The location if the shader is a geometry shader.\n"
		"\n"
		":type: ShaderGeometryMessageLocation\n"
		"\n"
		"", (void *) &ShaderMessageLocation_geometry_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderMessageLocation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderMessageLocation_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderMessageLocation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderMessageLocation",        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderMessageLocation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderMessageLocation_type.as_number,         /* tp_as_number */
    &SwigPyBuiltin__ShaderMessageLocation_type.as_sequence,       /* tp_as_sequence */
    &SwigPyBuiltin__ShaderMessageLocation_type.as_mapping,        /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderMessageLocation_type.as_buffer,         /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A shader message's location.",           /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderMessageLocation_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderMessageLocation_methods,                 /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderMessageLocation_getset,                  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderMessageLocation,                   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderMessageLocation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderMessageLocation_type};

static SwigPyGetSet ShaderMessage_disassemblyLine_getset = { _wrap_ShaderMessage_disassemblyLine_get, _wrap_ShaderMessage_disassemblyLine_set };
static SwigPyGetSet ShaderMessage_location_getset = { _wrap_ShaderMessage_location_get, _wrap_ShaderMessage_location_set };
static SwigPyGetSet ShaderMessage_stage_getset = { _wrap_ShaderMessage_stage_get, _wrap_ShaderMessage_stage_set };
static SwigPyGetSet ShaderMessage_message_getset = { _wrap_ShaderMessage_message_get, _wrap_ShaderMessage_message_set };
static SwigPyGetSet ShaderMessage___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderMessage_getset[] = {
    { (char *) "disassemblyLine", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The line (starting from 1) of the disassembly where this message came from, or -1 if\n"
		"it is not associated with any line.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderMessage_disassemblyLine_getset }
,
    { (char *) "location", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The location (thread/invocation) of the shader that this message comes from.\n"
		"\n"
		":type: ShaderMessageLocation\n"
		"\n"
		"", (void *) &ShaderMessage_location_getset }
,
    { (char *) "stage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The shader stage this message comes from.\n"
		"\n"
		":type: ShaderStage\n"
		"\n"
		"", (void *) &ShaderMessage_stage_getset }
,
    { (char *) "message", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The formatted message.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderMessage_message_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderMessage.__dict__", (void *) &ShaderMessage___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderMessage_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderMessage___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderMessage___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderMessage_methods[] = {
  { "__eq__", (PyCFunction) _wrap_ShaderMessage___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_ShaderMessage___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderMessage_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderMessage",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderMessage_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderMessage_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__ShaderMessage_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__ShaderMessage_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderMessage_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A shader printed message.",              /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderMessage_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderMessage_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderMessage_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderMessage,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderMessage_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderMessage_type};

static SwigPyGetSet D3D11Layout_semanticIndex_getset = { _wrap_D3D11Layout_semanticIndex_get, _wrap_D3D11Layout_semanticIndex_set };
static SwigPyGetSet D3D11Layout_semanticName_getset = { _wrap_D3D11Layout_semanticName_get, _wrap_D3D11Layout_semanticName_set };
static SwigPyGetSet D3D11Layout_instanceDataStepRate_getset = { _wrap_D3D11Layout_instanceDataStepRate_get, _wrap_D3D11Layout_instanceDataStepRate_set };
static SwigPyGetSet D3D11Layout_format_getset = { _wrap_D3D11Layout_format_get, _wrap_D3D11Layout_format_set };
static SwigPyGetSet D3D11Layout___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D11Layout_inputSlot_getset = { _wrap_D3D11Layout_inputSlot_get, _wrap_D3D11Layout_inputSlot_set };
static SwigPyGetSet D3D11Layout_byteOffset_getset = { _wrap_D3D11Layout_byteOffset_get, _wrap_D3D11Layout_byteOffset_set };
static SwigPyGetSet D3D11Layout_perInstance_getset = { _wrap_D3D11Layout_perInstance_get, _wrap_D3D11Layout_perInstance_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__Layout_getset[] = {
    { (char *) "semanticIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The semantic index for this input.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11Layout_semanticIndex_getset }
,
    { (char *) "semanticName", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The semantic name for this input.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &D3D11Layout_semanticName_getset }
,
    { (char *) "instanceDataStepRate", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If :data:`perInstance` is ``True`` then this is how many times each instance data is\n"
		"used before advancing to the next instance.\n"
		"\n"
		"E.g. if this value is two, then two instances will be drawn with the first instance data, then two\n"
		"with the next instance data.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11Layout_instanceDataStepRate_getset }
,
    { (char *) "format", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The format describing how the input data is interpreted.\n"
		"\n"
		":type: ResourceFormat\n"
		"\n"
		"", (void *) &D3D11Layout_format_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::Layout.__dict__", (void *) &D3D11Layout___dict___getset }
,
    { (char *) "inputSlot", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex buffer input slot where the data is sourced from.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11Layout_inputSlot_getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset from the start of the vertex data in the vertex buffer from\n"
		":data:`inputSlot`.\n"
		"\n"
		"If the value is :data:`TightlyPacked` then the element is packed tightly after the previous element, or 0\n"
		"if this is the first element.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11Layout_byteOffset_getset }
,
    { (char *) "perInstance", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the vertex data is instance-rate.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11Layout_perInstance_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__Layout_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_D3D11Layout___eq__(self, other); break;
    case Py_LT : result = _wrap_D3D11Layout___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__Layout_methods[] = {
  { "__eq__", (PyCFunction) _wrap_D3D11Layout___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_D3D11Layout___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__Layout_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11Layout",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11Layout_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__Layout_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__Layout_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__Layout_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__Layout_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Describes a single D3D11 input layout element for one vertex input.\n"
		"\n"
		".. data:: TightlyPacked\n"
		"\n"
		"  Value for :data:`byteOffset` that indicates this element is tightly packed.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__Layout_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__Layout_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__Layout_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D11Layout,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__Layout_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__Layout_type};

static SwigPyGetSet D3D11VertexBuffer_resourceId_getset = { _wrap_D3D11VertexBuffer_resourceId_get, _wrap_D3D11VertexBuffer_resourceId_set };
static SwigPyGetSet D3D11VertexBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D11VertexBuffer_byteStride_getset = { _wrap_D3D11VertexBuffer_byteStride_get, _wrap_D3D11VertexBuffer_byteStride_set };
static SwigPyGetSet D3D11VertexBuffer_byteOffset_getset = { _wrap_D3D11VertexBuffer_byteOffset_get, _wrap_D3D11VertexBuffer_byteOffset_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__VertexBuffer_getset[] = {
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the buffer bound to this slot.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D11VertexBuffer_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::VertexBuffer.__dict__", (void *) &D3D11VertexBuffer___dict___getset }
,
    { (char *) "byteStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte stride between the start of one set of vertex data and the next.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11VertexBuffer_byteStride_getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset from the start of the buffer to the beginning of the vertex data.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11VertexBuffer_byteOffset_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__VertexBuffer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_D3D11VertexBuffer___eq__(self, other); break;
    case Py_LT : result = _wrap_D3D11VertexBuffer___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__VertexBuffer_methods[] = {
  { "__eq__", (PyCFunction) _wrap_D3D11VertexBuffer___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_D3D11VertexBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__VertexBuffer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11VertexBuffer",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11VertexBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__VertexBuffer_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__VertexBuffer_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__VertexBuffer_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__VertexBuffer_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a single D3D11 vertex buffer binding.",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__VertexBuffer_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__VertexBuffer_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__VertexBuffer_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D11VertexBuffer,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__VertexBuffer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__VertexBuffer_type};

static SwigPyGetSet D3D11IndexBuffer_resourceId_getset = { _wrap_D3D11IndexBuffer_resourceId_get, _wrap_D3D11IndexBuffer_resourceId_set };
static SwigPyGetSet D3D11IndexBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D11IndexBuffer_byteStride_getset = { _wrap_D3D11IndexBuffer_byteStride_get, _wrap_D3D11IndexBuffer_byteStride_set };
static SwigPyGetSet D3D11IndexBuffer_byteOffset_getset = { _wrap_D3D11IndexBuffer_byteOffset_get, _wrap_D3D11IndexBuffer_byteOffset_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__IndexBuffer_getset[] = {
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the index buffer.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D11IndexBuffer_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::IndexBuffer.__dict__", (void *) &D3D11IndexBuffer___dict___getset }
,
    { (char *) "byteStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of bytes for each index in the index buffer. Typically 2 or 4 bytes but\n"
		"it can be 0 if no index buffer is bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11IndexBuffer_byteStride_getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset from the start of the buffer to the beginning of the index data.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11IndexBuffer_byteOffset_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__IndexBuffer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__IndexBuffer_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__IndexBuffer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11IndexBuffer",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11IndexBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__IndexBuffer_type.as_number,        /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__IndexBuffer_type.as_sequence,      /* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__IndexBuffer_type.as_mapping,       /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__IndexBuffer_type.as_buffer,        /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the D3D11 index buffer binding.",                  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__IndexBuffer_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__IndexBuffer_methods,                /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__IndexBuffer_getset,                 /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D11IndexBuffer,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__IndexBuffer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__IndexBuffer_type};

static SwigPyGetSet D3D11InputAssembly_bytecode_getset = { _wrap_D3D11InputAssembly_bytecode_get, _wrap_D3D11InputAssembly_bytecode_set };
static SwigPyGetSet D3D11InputAssembly_layouts_getset = { _wrap_D3D11InputAssembly_layouts_get, _wrap_D3D11InputAssembly_layouts_set };
static SwigPyGetSet D3D11InputAssembly_indexBuffer_getset = { _wrap_D3D11InputAssembly_indexBuffer_get, _wrap_D3D11InputAssembly_indexBuffer_set };
static SwigPyGetSet D3D11InputAssembly_resourceId_getset = { _wrap_D3D11InputAssembly_resourceId_get, _wrap_D3D11InputAssembly_resourceId_set };
static SwigPyGetSet D3D11InputAssembly_vertexBuffers_getset = { _wrap_D3D11InputAssembly_vertexBuffers_get, _wrap_D3D11InputAssembly_vertexBuffers_set };
static SwigPyGetSet D3D11InputAssembly___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D11InputAssembly_topology_getset = { _wrap_D3D11InputAssembly_topology_get, _wrap_D3D11InputAssembly_topology_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__InputAssembly_getset[] = {
    { (char *) "bytecode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The shader reflection for the bytecode used to create the input layout.\n"
		"\n"
		":type: ShaderReflection\n"
		"\n"
		"", (void *) &D3D11InputAssembly_bytecode_getset }
,
    { (char *) "layouts", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The input layout elements in this layout.\n"
		"\n"
		":type: List[D3D11Layout]\n"
		"\n"
		"", (void *) &D3D11InputAssembly_layouts_getset }
,
    { (char *) "indexBuffer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound index buffer.\n"
		"\n"
		":type: D3D11IndexBuffer\n"
		"\n"
		"", (void *) &D3D11InputAssembly_indexBuffer_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the layout object.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D11InputAssembly_resourceId_getset }
,
    { (char *) "vertexBuffers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound vertex buffers\n"
		"\n"
		":type: List[D3D11VertexBuffer]\n"
		"\n"
		"", (void *) &D3D11InputAssembly_vertexBuffers_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::InputAssembly.__dict__", (void *) &D3D11InputAssembly___dict___getset }
,
    { (char *) "topology", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current primitive topology.\n"
		"\n"
		":type: Topology\n"
		"\n"
		"", (void *) &D3D11InputAssembly_topology_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__InputAssembly_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__InputAssembly_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__InputAssembly_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11InputAssembly",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11InputAssembly_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__InputAssembly_type.as_number,      /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__InputAssembly_type.as_sequence,    /* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__InputAssembly_type.as_mapping,     /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__InputAssembly_type.as_buffer,      /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the input assembler data.",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__InputAssembly_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__InputAssembly_methods,              /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__InputAssembly_getset,               /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D11InputAssembly,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__InputAssembly_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__InputAssembly_type};

static SwigPyGetSet D3D11Shader_reflection_getset = { _wrap_D3D11Shader_reflection_get, _wrap_D3D11Shader_reflection_set };
static SwigPyGetSet D3D11Shader_classInstances_getset = { _wrap_D3D11Shader_classInstances_get, _wrap_D3D11Shader_classInstances_set };
static SwigPyGetSet D3D11Shader_resourceId_getset = { _wrap_D3D11Shader_resourceId_get, _wrap_D3D11Shader_resourceId_set };
static SwigPyGetSet D3D11Shader_stage_getset = { _wrap_D3D11Shader_stage_get, _wrap_D3D11Shader_stage_set };
static SwigPyGetSet D3D11Shader___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__Shader_getset[] = {
    { (char *) "reflection", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The reflection data for this shader.\n"
		"\n"
		":type: ShaderReflection\n"
		"\n"
		"", (void *) &D3D11Shader_reflection_getset }
,
    { (char *) "classInstances", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound class instance names.\n"
		"\n"
		":type: List[str]\n"
		"\n"
		"", (void *) &D3D11Shader_classInstances_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the shader itself.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D11Shader_resourceId_getset }
,
    { (char *) "stage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A :class:`ShaderStage` identifying which stage this shader is bound to.\n"
		"\n"
		":type: ShaderStage\n"
		"\n"
		"", (void *) &D3D11Shader_stage_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::Shader.__dict__", (void *) &D3D11Shader___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__Shader_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__Shader_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__Shader_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11Shader",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11Shader_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__Shader_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__Shader_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__Shader_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__Shader_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a D3D11 shader stage.",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__Shader_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__Shader_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__Shader_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D11Shader,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__Shader_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__Shader_type};

static SwigPyGetSet D3D11StreamOutBind_resourceId_getset = { _wrap_D3D11StreamOutBind_resourceId_get, _wrap_D3D11StreamOutBind_resourceId_set };
static SwigPyGetSet D3D11StreamOutBind___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D11StreamOutBind_byteOffset_getset = { _wrap_D3D11StreamOutBind_byteOffset_get, _wrap_D3D11StreamOutBind_byteOffset_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__StreamOutBind_getset[] = {
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the buffer.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D11StreamOutBind_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::StreamOutBind.__dict__", (void *) &D3D11StreamOutBind___dict___getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset of the stream-output binding.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11StreamOutBind_byteOffset_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__StreamOutBind_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_D3D11StreamOutBind___eq__(self, other); break;
    case Py_LT : result = _wrap_D3D11StreamOutBind___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__StreamOutBind_methods[] = {
  { "__eq__", (PyCFunction) _wrap_D3D11StreamOutBind___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_D3D11StreamOutBind___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__StreamOutBind_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11StreamOutBind",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11StreamOutBind_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__StreamOutBind_type.as_number,      /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__StreamOutBind_type.as_sequence,    /* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__StreamOutBind_type.as_mapping,     /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__StreamOutBind_type.as_buffer,      /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a binding on the D3D11 stream-out stage.",         /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__StreamOutBind_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__StreamOutBind_methods,              /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__StreamOutBind_getset,               /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D11StreamOutBind,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__StreamOutBind_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__StreamOutBind_type};

static SwigPyGetSet D3D11StreamOut___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D11StreamOut_rasterizedStream_getset = { _wrap_D3D11StreamOut_rasterizedStream_get, _wrap_D3D11StreamOut_rasterizedStream_set };
static SwigPyGetSet D3D11StreamOut_outputs_getset = { _wrap_D3D11StreamOut_outputs_get, _wrap_D3D11StreamOut_outputs_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__StreamOut_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::StreamOut.__dict__", (void *) &D3D11StreamOut___dict___getset }
,
    { (char *) "rasterizedStream", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Which stream-out stream is being used for rasterization.\n"
		"\n"
		"If the value is :data:`NoRasterization` then no stream has been selected for rasterization.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11StreamOut_rasterizedStream_getset }
,
    { (char *) "outputs", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound stream-out buffer bindings.\n"
		"\n"
		":type: List[D3D11StreamOutBind]\n"
		"\n"
		"", (void *) &D3D11StreamOut_outputs_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__StreamOut_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__StreamOut_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__StreamOut_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11StreamOut",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11StreamOut_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__StreamOut_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__StreamOut_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__StreamOut_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__StreamOut_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Describes the stream-out stage bindings.\n"
		"\n"
		".. data:: NoRasterization\n"
		"\n"
		"  Value for :data:`rasterizedStream` that indicates no stream is being rasterized.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__StreamOut_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__StreamOut_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__StreamOut_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D11StreamOut,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__StreamOut_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__StreamOut_type};

static SwigPyGetSet D3D11RasterizerState_depthBias_getset = { _wrap_D3D11RasterizerState_depthBias_get, _wrap_D3D11RasterizerState_depthBias_set };
static SwigPyGetSet D3D11RasterizerState_slopeScaledDepthBias_getset = { _wrap_D3D11RasterizerState_slopeScaledDepthBias_get, _wrap_D3D11RasterizerState_slopeScaledDepthBias_set };
static SwigPyGetSet D3D11RasterizerState_depthBiasClamp_getset = { _wrap_D3D11RasterizerState_depthBiasClamp_get, _wrap_D3D11RasterizerState_depthBiasClamp_set };
static SwigPyGetSet D3D11RasterizerState_fillMode_getset = { _wrap_D3D11RasterizerState_fillMode_get, _wrap_D3D11RasterizerState_fillMode_set };
static SwigPyGetSet D3D11RasterizerState_cullMode_getset = { _wrap_D3D11RasterizerState_cullMode_get, _wrap_D3D11RasterizerState_cullMode_set };
static SwigPyGetSet D3D11RasterizerState_depthClip_getset = { _wrap_D3D11RasterizerState_depthClip_get, _wrap_D3D11RasterizerState_depthClip_set };
static SwigPyGetSet D3D11RasterizerState_resourceId_getset = { _wrap_D3D11RasterizerState_resourceId_get, _wrap_D3D11RasterizerState_resourceId_set };
static SwigPyGetSet D3D11RasterizerState_antialiasedLines_getset = { _wrap_D3D11RasterizerState_antialiasedLines_get, _wrap_D3D11RasterizerState_antialiasedLines_set };
static SwigPyGetSet D3D11RasterizerState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D11RasterizerState_frontCCW_getset = { _wrap_D3D11RasterizerState_frontCCW_get, _wrap_D3D11RasterizerState_frontCCW_set };
static SwigPyGetSet D3D11RasterizerState_multisampleEnable_getset = { _wrap_D3D11RasterizerState_multisampleEnable_get, _wrap_D3D11RasterizerState_multisampleEnable_set };
static SwigPyGetSet D3D11RasterizerState_forcedSampleCount_getset = { _wrap_D3D11RasterizerState_forcedSampleCount_get, _wrap_D3D11RasterizerState_forcedSampleCount_set };
static SwigPyGetSet D3D11RasterizerState_scissorEnable_getset = { _wrap_D3D11RasterizerState_scissorEnable_get, _wrap_D3D11RasterizerState_scissorEnable_set };
static SwigPyGetSet D3D11RasterizerState_conservativeRasterization_getset = { _wrap_D3D11RasterizerState_conservativeRasterization_get, _wrap_D3D11RasterizerState_conservativeRasterization_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__RasterizerState_getset[] = {
    { (char *) "depthBias", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed depth bias value to apply to z-values.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11RasterizerState_depthBias_getset }
,
    { (char *) "slopeScaledDepthBias", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The slope-scaled depth bias value to apply to z-values.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &D3D11RasterizerState_slopeScaledDepthBias_getset }
,
    { (char *) "depthBiasClamp", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The clamp value for calculated depth bias from :data:`depthBias` and\n"
		":data:`slopeScaledDepthBias`\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &D3D11RasterizerState_depthBiasClamp_getset }
,
    { (char *) "fillMode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The polygon :class:`FillMode`.\n"
		"\n"
		":type: FillMode\n"
		"\n"
		"", (void *) &D3D11RasterizerState_fillMode_getset }
,
    { (char *) "cullMode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The polygon :class:`CullMode`.\n"
		"\n"
		":type: CullMode\n"
		"\n"
		"", (void *) &D3D11RasterizerState_cullMode_getset }
,
    { (char *) "depthClip", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if pixels outside of the near and far depth planes should be clipped.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11RasterizerState_depthClip_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the rasterizer state object.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D11RasterizerState_resourceId_getset }
,
    { (char *) "antialiasedLines", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if lines should be anti-aliased. Ignored if :data:`multisampleEnable` is  ``False``.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11RasterizerState_antialiasedLines_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::RasterizerState.__dict__", (void *) &D3D11RasterizerState___dict___getset }
,
    { (char *) "frontCCW", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if counter-clockwise polygons are front-facing.\n"
		"``False`` if clockwise polygons are front-facing.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11RasterizerState_frontCCW_getset }
,
    { (char *) "multisampleEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the quadrilateral MSAA algorithm should be used on MSAA targets.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11RasterizerState_multisampleEnable_getset }
,
    { (char *) "forcedSampleCount", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A sample count to force rasterization to when UAV rendering or rasterizing, or 0 to\n"
		"not force any sample count.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11RasterizerState_forcedSampleCount_getset }
,
    { (char *) "scissorEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the scissor test should be applied.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11RasterizerState_scissorEnable_getset }
,
    { (char *) "conservativeRasterization", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current :class:`ConservativeRaster` mode.\n"
		"\n"
		":type: ConservativeRaster\n"
		"\n"
		"", (void *) &D3D11RasterizerState_conservativeRasterization_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__RasterizerState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__RasterizerState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__RasterizerState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11RasterizerState",         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11RasterizerState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__RasterizerState_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__RasterizerState_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__RasterizerState_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__RasterizerState_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a rasterizer state object.",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__RasterizerState_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__RasterizerState_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__RasterizerState_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D11RasterizerState,/* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__RasterizerState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__RasterizerState_type};

static SwigPyGetSet D3D11Rasterizer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D11Rasterizer_scissors_getset = { _wrap_D3D11Rasterizer_scissors_get, _wrap_D3D11Rasterizer_scissors_set };
static SwigPyGetSet D3D11Rasterizer_state_getset = { _wrap_D3D11Rasterizer_state_get, _wrap_D3D11Rasterizer_state_set };
static SwigPyGetSet D3D11Rasterizer_viewports_getset = { _wrap_D3D11Rasterizer_viewports_get, _wrap_D3D11Rasterizer_viewports_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__Rasterizer_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::Rasterizer.__dict__", (void *) &D3D11Rasterizer___dict___getset }
,
    { (char *) "scissors", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound scissor regions.\n"
		"\n"
		":type: List[Scissor]\n"
		"\n"
		"", (void *) &D3D11Rasterizer_scissors_getset }
,
    { (char *) "state", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The details of the rasterization state.\n"
		"\n"
		":type: D3D11RasterizerState\n"
		"\n"
		"", (void *) &D3D11Rasterizer_state_getset }
,
    { (char *) "viewports", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound viewports.\n"
		"\n"
		":type: List[Viewport]\n"
		"\n"
		"", (void *) &D3D11Rasterizer_viewports_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__Rasterizer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__Rasterizer_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__Rasterizer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11Rasterizer",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11Rasterizer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__Rasterizer_type.as_number,         /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__Rasterizer_type.as_sequence,       /* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__Rasterizer_type.as_mapping,        /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__Rasterizer_type.as_buffer,         /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the rasterization state of the D3D11 pipeline.",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__Rasterizer_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__Rasterizer_methods,                 /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__Rasterizer_getset,                  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D11Rasterizer,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__Rasterizer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__Rasterizer_type};

static SwigPyGetSet D3D11DepthStencilState_frontFace_getset = { _wrap_D3D11DepthStencilState_frontFace_get, _wrap_D3D11DepthStencilState_frontFace_set };
static SwigPyGetSet D3D11DepthStencilState_resourceId_getset = { _wrap_D3D11DepthStencilState_resourceId_get, _wrap_D3D11DepthStencilState_resourceId_set };
static SwigPyGetSet D3D11DepthStencilState_backFace_getset = { _wrap_D3D11DepthStencilState_backFace_get, _wrap_D3D11DepthStencilState_backFace_set };
static SwigPyGetSet D3D11DepthStencilState_depthFunction_getset = { _wrap_D3D11DepthStencilState_depthFunction_get, _wrap_D3D11DepthStencilState_depthFunction_set };
static SwigPyGetSet D3D11DepthStencilState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D11DepthStencilState_depthEnable_getset = { _wrap_D3D11DepthStencilState_depthEnable_get, _wrap_D3D11DepthStencilState_depthEnable_set };
static SwigPyGetSet D3D11DepthStencilState_depthWrites_getset = { _wrap_D3D11DepthStencilState_depthWrites_get, _wrap_D3D11DepthStencilState_depthWrites_set };
static SwigPyGetSet D3D11DepthStencilState_stencilEnable_getset = { _wrap_D3D11DepthStencilState_stencilEnable_get, _wrap_D3D11DepthStencilState_stencilEnable_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__DepthStencilState_getset[] = {
    { (char *) "frontFace", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stencil state for front-facing polygons.\n"
		"\n"
		":type: StencilFace\n"
		"\n"
		"", (void *) &D3D11DepthStencilState_frontFace_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the depth-stencil state object.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D11DepthStencilState_resourceId_getset }
,
    { (char *) "backFace", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stencil state for back-facing polygons.\n"
		"\n"
		":type: StencilFace\n"
		"\n"
		"", (void *) &D3D11DepthStencilState_backFace_getset }
,
    { (char *) "depthFunction", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`CompareFunction` to use for testing depth values.\n"
		"\n"
		":type: CompareFunction\n"
		"\n"
		"", (void *) &D3D11DepthStencilState_depthFunction_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::DepthStencilState.__dict__", (void *) &D3D11DepthStencilState___dict___getset }
,
    { (char *) "depthEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth testing should be performed.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11DepthStencilState_depthEnable_getset }
,
    { (char *) "depthWrites", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth values should be written to the depth target.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11DepthStencilState_depthWrites_getset }
,
    { (char *) "stencilEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if stencil operations should be performed.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11DepthStencilState_stencilEnable_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__DepthStencilState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__DepthStencilState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__DepthStencilState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11DepthStencilState",       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11DepthStencilState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__DepthStencilState_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__DepthStencilState_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__DepthStencilState_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__DepthStencilState_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a depth-stencil state object.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__DepthStencilState_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__DepthStencilState_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__DepthStencilState_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D11DepthStencilState,                  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__DepthStencilState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__DepthStencilState_type};

static SwigPyGetSet D3D11BlendState_blends_getset = { _wrap_D3D11BlendState_blends_get, _wrap_D3D11BlendState_blends_set };
static SwigPyGetSet D3D11BlendState_independentBlend_getset = { _wrap_D3D11BlendState_independentBlend_get, _wrap_D3D11BlendState_independentBlend_set };
static SwigPyGetSet D3D11BlendState_resourceId_getset = { _wrap_D3D11BlendState_resourceId_get, _wrap_D3D11BlendState_resourceId_set };
static SwigPyGetSet D3D11BlendState_blendFactor_getset = { _wrap_D3D11BlendState_blendFactor_get, _wrap_D3D11BlendState_blendFactor_set };
static SwigPyGetSet D3D11BlendState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D11BlendState_sampleMask_getset = { _wrap_D3D11BlendState_sampleMask_get, _wrap_D3D11BlendState_sampleMask_set };
static SwigPyGetSet D3D11BlendState_alphaToCoverage_getset = { _wrap_D3D11BlendState_alphaToCoverage_get, _wrap_D3D11BlendState_alphaToCoverage_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__BlendState_getset[] = {
    { (char *) "blends", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The blend operations for each target.\n"
		"\n"
		":type: List[ColorBlend]\n"
		"\n"
		"", (void *) &D3D11BlendState_blends_getset }
,
    { (char *) "independentBlend", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if independent blending for each target should be used.\n"
		"\n"
		"``False`` if the first blend should be applied to all targets.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11BlendState_independentBlend_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the blend state object.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D11BlendState_resourceId_getset }
,
    { (char *) "blendFactor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The constant blend factor to use in blend equations.\n"
		"\n"
		":type: Tuple[float,float,float,float]\n"
		"\n"
		"", (void *) &D3D11BlendState_blendFactor_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::BlendState.__dict__", (void *) &D3D11BlendState___dict___getset }
,
    { (char *) "sampleMask", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The mask determining which samples are written to.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11BlendState_sampleMask_getset }
,
    { (char *) "alphaToCoverage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if alpha-to-coverage should be used when blending to an MSAA target.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11BlendState_alphaToCoverage_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__BlendState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__BlendState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__BlendState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11BlendState",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11BlendState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__BlendState_type.as_number,         /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__BlendState_type.as_sequence,       /* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__BlendState_type.as_mapping,        /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__BlendState_type.as_buffer,         /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a blend state object.",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__BlendState_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__BlendState_methods,                 /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__BlendState_getset,                  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D11BlendState,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__BlendState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__BlendState_type};

static SwigPyGetSet D3D11OutputMerger_depthStencilState_getset = { _wrap_D3D11OutputMerger_depthStencilState_get, _wrap_D3D11OutputMerger_depthStencilState_set };
static SwigPyGetSet D3D11OutputMerger_depthTarget_getset = { _wrap_D3D11OutputMerger_depthTarget_get, _wrap_D3D11OutputMerger_depthTarget_set };
static SwigPyGetSet D3D11OutputMerger_depthReadOnly_getset = { _wrap_D3D11OutputMerger_depthReadOnly_get, _wrap_D3D11OutputMerger_depthReadOnly_set };
static SwigPyGetSet D3D11OutputMerger_stencilReadOnly_getset = { _wrap_D3D11OutputMerger_stencilReadOnly_get, _wrap_D3D11OutputMerger_stencilReadOnly_set };
static SwigPyGetSet D3D11OutputMerger___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D11OutputMerger_uavStartSlot_getset = { _wrap_D3D11OutputMerger_uavStartSlot_get, _wrap_D3D11OutputMerger_uavStartSlot_set };
static SwigPyGetSet D3D11OutputMerger_renderTargets_getset = { _wrap_D3D11OutputMerger_renderTargets_get, _wrap_D3D11OutputMerger_renderTargets_set };
static SwigPyGetSet D3D11OutputMerger_blendState_getset = { _wrap_D3D11OutputMerger_blendState_get, _wrap_D3D11OutputMerger_blendState_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__OutputMerger_getset[] = {
    { (char *) "depthStencilState", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current depth-stencil state details.\n"
		"\n"
		":type: D3D11DepthStencilState\n"
		"\n"
		"", (void *) &D3D11OutputMerger_depthStencilState_getset }
,
    { (char *) "depthTarget", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The currently bound depth-stencil target.\n"
		"\n"
		":type: Descriptor\n"
		"\n"
		"", (void *) &D3D11OutputMerger_depthTarget_getset }
,
    { (char *) "depthReadOnly", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth access to the depth-stencil target is read-only.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11OutputMerger_depthReadOnly_getset }
,
    { (char *) "stencilReadOnly", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if stencil access to the depth-stencil target is read-only.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11OutputMerger_stencilReadOnly_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::OutputMerger.__dict__", (void *) &D3D11OutputMerger___dict___getset }
,
    { (char *) "uavStartSlot", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Which slot in the output targets is the first UAV.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11OutputMerger_uavStartSlot_getset }
,
    { (char *) "renderTargets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound render targets.\n"
		"\n"
		":type: List[Descriptor]\n"
		"\n"
		"", (void *) &D3D11OutputMerger_renderTargets_getset }
,
    { (char *) "blendState", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current blend state details.\n"
		"\n"
		":type: D3D11BlendState\n"
		"\n"
		"", (void *) &D3D11OutputMerger_blendState_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__OutputMerger_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__OutputMerger_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__OutputMerger_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11OutputMerger",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11OutputMerger_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__OutputMerger_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__OutputMerger_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__OutputMerger_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__OutputMerger_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the current state of the output-merger stage of the D3D11 pipeline.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__OutputMerger_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__OutputMerger_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__OutputMerger_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D11OutputMerger,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__OutputMerger_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__OutputMerger_type};

static SwigPyGetSet D3D11Predication_value_getset = { _wrap_D3D11Predication_value_get, _wrap_D3D11Predication_value_set };
static SwigPyGetSet D3D11Predication_resourceId_getset = { _wrap_D3D11Predication_resourceId_get, _wrap_D3D11Predication_resourceId_set };
static SwigPyGetSet D3D11Predication___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D11Predication_isPassing_getset = { _wrap_D3D11Predication_isPassing_get, _wrap_D3D11Predication_isPassing_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__Predication_getset[] = {
    { (char *) "value", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value to go along with the predicate.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11Predication_value_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the active predicate.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D11Predication_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::Predication.__dict__", (void *) &D3D11Predication___dict___getset }
,
    { (char *) "isPassing", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the current predicate would render.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D11Predication_isPassing_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__Predication_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__Predication_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__Predication_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11Predication",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11Predication_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__Predication_type.as_number,        /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__Predication_type.as_sequence,      /* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__Predication_type.as_mapping,       /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__Predication_type.as_buffer,        /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the current state of D3D11 predicated rendering.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__Predication_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__Predication_methods,                /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__Predication_getset,                 /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D11Predication,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__Predication_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__Predication_type};

static SwigPyGetSet D3D11State_streamOut_getset = { _wrap_D3D11State_streamOut_get, _wrap_D3D11State_streamOut_set };
static SwigPyGetSet D3D11State_outputMerger_getset = { _wrap_D3D11State_outputMerger_get, _wrap_D3D11State_outputMerger_set };
static SwigPyGetSet D3D11State_predication_getset = { _wrap_D3D11State_predication_get, _wrap_D3D11State_predication_set };
static SwigPyGetSet D3D11State_descriptorStore_getset = { _wrap_D3D11State_descriptorStore_get, _wrap_D3D11State_descriptorStore_set };
static SwigPyGetSet D3D11State_descriptorCount_getset = { _wrap_D3D11State_descriptorCount_get, _wrap_D3D11State_descriptorCount_set };
static SwigPyGetSet D3D11State___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D11State_inputAssembly_getset = { _wrap_D3D11State_inputAssembly_get, _wrap_D3D11State_inputAssembly_set };
static SwigPyGetSet D3D11State_geometryShader_getset = { _wrap_D3D11State_geometryShader_get, _wrap_D3D11State_geometryShader_set };
static SwigPyGetSet D3D11State_computeShader_getset = { _wrap_D3D11State_computeShader_get, _wrap_D3D11State_computeShader_set };
static SwigPyGetSet D3D11State_descriptorByteSize_getset = { _wrap_D3D11State_descriptorByteSize_get, _wrap_D3D11State_descriptorByteSize_set };
static SwigPyGetSet D3D11State_rasterizer_getset = { _wrap_D3D11State_rasterizer_get, _wrap_D3D11State_rasterizer_set };
static SwigPyGetSet D3D11State_vertexShader_getset = { _wrap_D3D11State_vertexShader_get, _wrap_D3D11State_vertexShader_set };
static SwigPyGetSet D3D11State_hullShader_getset = { _wrap_D3D11State_hullShader_get, _wrap_D3D11State_hullShader_set };
static SwigPyGetSet D3D11State_domainShader_getset = { _wrap_D3D11State_domainShader_get, _wrap_D3D11State_domainShader_set };
static SwigPyGetSet D3D11State_pixelShader_getset = { _wrap_D3D11State_pixelShader_get, _wrap_D3D11State_pixelShader_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D11Pipe__State_getset[] = {
    { (char *) "streamOut", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stream-out pipeline stage.\n"
		"\n"
		":type: D3D11StreamOut\n"
		"\n"
		"", (void *) &D3D11State_streamOut_getset }
,
    { (char *) "outputMerger", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The output merger pipeline stage.\n"
		"\n"
		":type: D3D11OutputMerger\n"
		"\n"
		"", (void *) &D3D11State_outputMerger_getset }
,
    { (char *) "predication", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The predicated rendering state.\n"
		"\n"
		":type: D3D11Predication\n"
		"\n"
		"", (void *) &D3D11State_predication_getset }
,
    { (char *) "descriptorStore", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The virtual descriptor storage.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D11State_descriptorStore_getset }
,
    { (char *) "descriptorCount", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of descriptors in the virtual descriptor storage.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11State_descriptorCount_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D11Pipe::State.__dict__", (void *) &D3D11State___dict___getset }
,
    { (char *) "inputAssembly", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The input assembly pipeline stage.\n"
		"\n"
		":type: D3D11InputAssembly\n"
		"\n"
		"", (void *) &D3D11State_inputAssembly_getset }
,
    { (char *) "geometryShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The geometry shader stage.\n"
		"\n"
		":type: D3D11Shader\n"
		"\n"
		"", (void *) &D3D11State_geometryShader_getset }
,
    { (char *) "computeShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The compute shader stage.\n"
		"\n"
		":type: D3D11Shader\n"
		"\n"
		"", (void *) &D3D11State_computeShader_getset }
,
    { (char *) "descriptorByteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte size of a descriptor in the virtual descriptor storage.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D11State_descriptorByteSize_getset }
,
    { (char *) "rasterizer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The rasterizer pipeline stage.\n"
		"\n"
		":type: D3D11Rasterizer\n"
		"\n"
		"", (void *) &D3D11State_rasterizer_getset }
,
    { (char *) "vertexShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex shader stage.\n"
		"\n"
		":type: D3D11Shader\n"
		"\n"
		"", (void *) &D3D11State_vertexShader_getset }
,
    { (char *) "hullShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The hull shader stage.\n"
		"\n"
		":type: D3D11Shader\n"
		"\n"
		"", (void *) &D3D11State_hullShader_getset }
,
    { (char *) "domainShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The domain shader stage.\n"
		"\n"
		":type: D3D11Shader\n"
		"\n"
		"", (void *) &D3D11State_domainShader_getset }
,
    { (char *) "pixelShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The pixel shader stage.\n"
		"\n"
		":type: D3D11Shader\n"
		"\n"
		"", (void *) &D3D11State_pixelShader_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D11Pipe__State_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D11Pipe__State_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D11Pipe__State_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D11State",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D11State_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D11Pipe__State_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__D3D11Pipe__State_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__D3D11Pipe__State_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D11Pipe__State_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The full current D3D11 pipeline state.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D11Pipe__State_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D11Pipe__State_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D11Pipe__State_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D11Pipe__State_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__State_type};

static SwigPyGetSet D3D12Layout_semanticIndex_getset = { _wrap_D3D12Layout_semanticIndex_get, _wrap_D3D12Layout_semanticIndex_set };
static SwigPyGetSet D3D12Layout_semanticName_getset = { _wrap_D3D12Layout_semanticName_get, _wrap_D3D12Layout_semanticName_set };
static SwigPyGetSet D3D12Layout_instanceDataStepRate_getset = { _wrap_D3D12Layout_instanceDataStepRate_get, _wrap_D3D12Layout_instanceDataStepRate_set };
static SwigPyGetSet D3D12Layout_format_getset = { _wrap_D3D12Layout_format_get, _wrap_D3D12Layout_format_set };
static SwigPyGetSet D3D12Layout___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12Layout_inputSlot_getset = { _wrap_D3D12Layout_inputSlot_get, _wrap_D3D12Layout_inputSlot_set };
static SwigPyGetSet D3D12Layout_byteOffset_getset = { _wrap_D3D12Layout_byteOffset_get, _wrap_D3D12Layout_byteOffset_set };
static SwigPyGetSet D3D12Layout_perInstance_getset = { _wrap_D3D12Layout_perInstance_get, _wrap_D3D12Layout_perInstance_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__Layout_getset[] = {
    { (char *) "semanticIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The semantic index for this input.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12Layout_semanticIndex_getset }
,
    { (char *) "semanticName", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The semantic name for this input.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &D3D12Layout_semanticName_getset }
,
    { (char *) "instanceDataStepRate", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If :data:`perInstance` is ``True`` then this is how many times each instance data is\n"
		"used before advancing to the next instance.\n"
		"\n"
		"E.g. if this value is two, then two instances will be drawn with the first instance data, then two\n"
		"with the next instance data.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12Layout_instanceDataStepRate_getset }
,
    { (char *) "format", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The format describing how the input data is interpreted.\n"
		"\n"
		":type: ResourceFormat\n"
		"\n"
		"", (void *) &D3D12Layout_format_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::Layout.__dict__", (void *) &D3D12Layout___dict___getset }
,
    { (char *) "inputSlot", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex buffer input slot where the data is sourced from.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12Layout_inputSlot_getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset from the start of the vertex data in the vertex buffer from\n"
		":data:`inputSlot`.\n"
		"\n"
		"If the value is :data:`TightlyPacked` then the element is packed tightly after the previous element, or 0\n"
		"if this is the first element.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12Layout_byteOffset_getset }
,
    { (char *) "perInstance", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the vertex data is instance-rate.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D12Layout_perInstance_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__Layout_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_D3D12Layout___eq__(self, other); break;
    case Py_LT : result = _wrap_D3D12Layout___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__Layout_methods[] = {
  { "__eq__", (PyCFunction) _wrap_D3D12Layout___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_D3D12Layout___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__Layout_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12Layout",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12Layout_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__Layout_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__Layout_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__Layout_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__Layout_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Describes a single D3D12 input layout element for one vertex input.\n"
		"\n"
		".. data:: TightlyPacked\n"
		"\n"
		"  Value for :data:`byteOffset` that indicates this element is tightly packed.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__Layout_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__Layout_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__Layout_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12Layout,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__Layout_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__Layout_type};

static SwigPyGetSet D3D12VertexBuffer_resourceId_getset = { _wrap_D3D12VertexBuffer_resourceId_get, _wrap_D3D12VertexBuffer_resourceId_set };
static SwigPyGetSet D3D12VertexBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12VertexBuffer_byteStride_getset = { _wrap_D3D12VertexBuffer_byteStride_get, _wrap_D3D12VertexBuffer_byteStride_set };
static SwigPyGetSet D3D12VertexBuffer_byteOffset_getset = { _wrap_D3D12VertexBuffer_byteOffset_get, _wrap_D3D12VertexBuffer_byteOffset_set };
static SwigPyGetSet D3D12VertexBuffer_byteSize_getset = { _wrap_D3D12VertexBuffer_byteSize_get, _wrap_D3D12VertexBuffer_byteSize_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__VertexBuffer_getset[] = {
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the buffer bound to this slot.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D12VertexBuffer_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::VertexBuffer.__dict__", (void *) &D3D12VertexBuffer___dict___getset }
,
    { (char *) "byteStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte stride between the start of one set of vertex data and the next.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12VertexBuffer_byteStride_getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset from the start of the buffer to the beginning of the vertex data.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12VertexBuffer_byteOffset_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of bytes available in this vertex buffer.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12VertexBuffer_byteSize_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__VertexBuffer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_D3D12VertexBuffer___eq__(self, other); break;
    case Py_LT : result = _wrap_D3D12VertexBuffer___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__VertexBuffer_methods[] = {
  { "__eq__", (PyCFunction) _wrap_D3D12VertexBuffer___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_D3D12VertexBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__VertexBuffer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12VertexBuffer",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12VertexBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__VertexBuffer_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__VertexBuffer_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__VertexBuffer_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__VertexBuffer_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a single D3D12 vertex buffer binding.",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__VertexBuffer_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__VertexBuffer_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__VertexBuffer_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12VertexBuffer,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__VertexBuffer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__VertexBuffer_type};

static SwigPyGetSet D3D12IndexBuffer_resourceId_getset = { _wrap_D3D12IndexBuffer_resourceId_get, _wrap_D3D12IndexBuffer_resourceId_set };
static SwigPyGetSet D3D12IndexBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12IndexBuffer_byteStride_getset = { _wrap_D3D12IndexBuffer_byteStride_get, _wrap_D3D12IndexBuffer_byteStride_set };
static SwigPyGetSet D3D12IndexBuffer_byteOffset_getset = { _wrap_D3D12IndexBuffer_byteOffset_get, _wrap_D3D12IndexBuffer_byteOffset_set };
static SwigPyGetSet D3D12IndexBuffer_byteSize_getset = { _wrap_D3D12IndexBuffer_byteSize_get, _wrap_D3D12IndexBuffer_byteSize_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__IndexBuffer_getset[] = {
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the index buffer.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D12IndexBuffer_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::IndexBuffer.__dict__", (void *) &D3D12IndexBuffer___dict___getset }
,
    { (char *) "byteStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of bytes for each index in the index buffer. Typically 2 or 4 bytes but\n"
		"it can be 0 if no index buffer is bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12IndexBuffer_byteStride_getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset from the start of the buffer to the beginning of the index data.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12IndexBuffer_byteOffset_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of bytes available in this index buffer.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12IndexBuffer_byteSize_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__IndexBuffer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__IndexBuffer_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__IndexBuffer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12IndexBuffer",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12IndexBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__IndexBuffer_type.as_number,        /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__IndexBuffer_type.as_sequence,      /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__IndexBuffer_type.as_mapping,       /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__IndexBuffer_type.as_buffer,        /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the D3D12 index buffer binding.",                  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__IndexBuffer_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__IndexBuffer_methods,                /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__IndexBuffer_getset,                 /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12IndexBuffer,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__IndexBuffer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__IndexBuffer_type};

static SwigPyGetSet D3D12InputAssembly_layouts_getset = { _wrap_D3D12InputAssembly_layouts_get, _wrap_D3D12InputAssembly_layouts_set };
static SwigPyGetSet D3D12InputAssembly_indexBuffer_getset = { _wrap_D3D12InputAssembly_indexBuffer_get, _wrap_D3D12InputAssembly_indexBuffer_set };
static SwigPyGetSet D3D12InputAssembly_indexStripCutValue_getset = { _wrap_D3D12InputAssembly_indexStripCutValue_get, _wrap_D3D12InputAssembly_indexStripCutValue_set };
static SwigPyGetSet D3D12InputAssembly_vertexBuffers_getset = { _wrap_D3D12InputAssembly_vertexBuffers_get, _wrap_D3D12InputAssembly_vertexBuffers_set };
static SwigPyGetSet D3D12InputAssembly___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12InputAssembly_topology_getset = { _wrap_D3D12InputAssembly_topology_get, _wrap_D3D12InputAssembly_topology_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__InputAssembly_getset[] = {
    { (char *) "layouts", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The input layout elements in this layout.\n"
		"\n"
		":type: List[D3D12Layout]\n"
		"\n"
		"", (void *) &D3D12InputAssembly_layouts_getset }
,
    { (char *) "indexBuffer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound index buffer.\n"
		"\n"
		":type: D3D12IndexBuffer\n"
		"\n"
		"", (void *) &D3D12InputAssembly_indexBuffer_getset }
,
    { (char *) "indexStripCutValue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index value to use for cutting strips. Either ``0``, ``0xffff`` or ``0xffffffff``.\n"
		"If the value is 0, strip cutting is disabled.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12InputAssembly_indexStripCutValue_getset }
,
    { (char *) "vertexBuffers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound vertex buffers\n"
		"\n"
		":type: List[D3D12VertexBuffer]\n"
		"\n"
		"", (void *) &D3D12InputAssembly_vertexBuffers_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::InputAssembly.__dict__", (void *) &D3D12InputAssembly___dict___getset }
,
    { (char *) "topology", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current primitive topology.\n"
		"\n"
		":type: Topology\n"
		"\n"
		"", (void *) &D3D12InputAssembly_topology_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__InputAssembly_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__InputAssembly_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__InputAssembly_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12InputAssembly",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12InputAssembly_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__InputAssembly_type.as_number,      /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__InputAssembly_type.as_sequence,    /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__InputAssembly_type.as_mapping,     /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__InputAssembly_type.as_buffer,      /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the input assembler state in the PSO.",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__InputAssembly_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__InputAssembly_methods,              /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__InputAssembly_getset,               /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12InputAssembly,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__InputAssembly_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__InputAssembly_type};

static SwigPyGetSet D3D12Shader_reflection_getset = { _wrap_D3D12Shader_reflection_get, _wrap_D3D12Shader_reflection_set };
static SwigPyGetSet D3D12Shader_resourceId_getset = { _wrap_D3D12Shader_resourceId_get, _wrap_D3D12Shader_resourceId_set };
static SwigPyGetSet D3D12Shader_stage_getset = { _wrap_D3D12Shader_stage_get, _wrap_D3D12Shader_stage_set };
static SwigPyGetSet D3D12Shader___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__Shader_getset[] = {
    { (char *) "reflection", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The reflection data for this shader.\n"
		"\n"
		":type: ShaderReflection\n"
		"\n"
		"", (void *) &D3D12Shader_reflection_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the shader object itself.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D12Shader_resourceId_getset }
,
    { (char *) "stage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A :class:`ShaderStage` identifying which stage this shader is bound to.\n"
		"\n"
		":type: ShaderStage\n"
		"\n"
		"", (void *) &D3D12Shader_stage_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::Shader.__dict__", (void *) &D3D12Shader___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__Shader_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__Shader_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__Shader_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12Shader",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12Shader_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__Shader_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__Shader_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__Shader_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__Shader_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a D3D12 shader stage.",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__Shader_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__Shader_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__Shader_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12Shader,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__Shader_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__Shader_type};

static SwigPyGetSet D3D12StreamOutBind_resourceId_getset = { _wrap_D3D12StreamOutBind_resourceId_get, _wrap_D3D12StreamOutBind_resourceId_set };
static SwigPyGetSet D3D12StreamOutBind_writtenCountResourceId_getset = { _wrap_D3D12StreamOutBind_writtenCountResourceId_get, _wrap_D3D12StreamOutBind_writtenCountResourceId_set };
static SwigPyGetSet D3D12StreamOutBind___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12StreamOutBind_byteOffset_getset = { _wrap_D3D12StreamOutBind_byteOffset_get, _wrap_D3D12StreamOutBind_byteOffset_set };
static SwigPyGetSet D3D12StreamOutBind_writtenCountByteOffset_getset = { _wrap_D3D12StreamOutBind_writtenCountByteOffset_get, _wrap_D3D12StreamOutBind_writtenCountByteOffset_set };
static SwigPyGetSet D3D12StreamOutBind_byteSize_getset = { _wrap_D3D12StreamOutBind_byteSize_get, _wrap_D3D12StreamOutBind_byteSize_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__StreamOutBind_getset[] = {
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the buffer.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D12StreamOutBind_resourceId_getset }
,
    { (char *) "writtenCountResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the buffer where the written count will be stored.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D12StreamOutBind_writtenCountResourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::StreamOutBind.__dict__", (void *) &D3D12StreamOutBind___dict___getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset in :data:`resourceId` where the buffer view starts in the underlying\n"
		"buffer.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12StreamOutBind_byteOffset_getset }
,
    { (char *) "writtenCountByteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset in :data:`writtenCountResourceId` where the stream-out count will be\n"
		"written.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12StreamOutBind_writtenCountByteOffset_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many bytes are in this stream-out buffer view.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12StreamOutBind_byteSize_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__StreamOutBind_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_D3D12StreamOutBind___eq__(self, other); break;
    case Py_LT : result = _wrap_D3D12StreamOutBind___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__StreamOutBind_methods[] = {
  { "__eq__", (PyCFunction) _wrap_D3D12StreamOutBind___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_D3D12StreamOutBind___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__StreamOutBind_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12StreamOutBind",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12StreamOutBind_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__StreamOutBind_type.as_number,      /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__StreamOutBind_type.as_sequence,    /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__StreamOutBind_type.as_mapping,     /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__StreamOutBind_type.as_buffer,      /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a binding on the D3D12 stream-out stage.",         /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__StreamOutBind_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__StreamOutBind_methods,              /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__StreamOutBind_getset,               /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12StreamOutBind,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__StreamOutBind_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__StreamOutBind_type};

static SwigPyGetSet D3D12StreamOut___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12StreamOut_rasterizedStream_getset = { _wrap_D3D12StreamOut_rasterizedStream_get, _wrap_D3D12StreamOut_rasterizedStream_set };
static SwigPyGetSet D3D12StreamOut_outputs_getset = { _wrap_D3D12StreamOut_outputs_get, _wrap_D3D12StreamOut_outputs_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__StreamOut_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::StreamOut.__dict__", (void *) &D3D12StreamOut___dict___getset }
,
    { (char *) "rasterizedStream", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Which stream-out stream is being used for rasterization.\n"
		"\n"
		"If the value is :data:`NoRasterization` then no stream has been selected for rasterization.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12StreamOut_rasterizedStream_getset }
,
    { (char *) "outputs", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound stream-out buffer bindings.\n"
		"\n"
		":type: List[D3D12StreamOutBind]\n"
		"\n"
		"", (void *) &D3D12StreamOut_outputs_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__StreamOut_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__StreamOut_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__StreamOut_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12StreamOut",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12StreamOut_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__StreamOut_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__StreamOut_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__StreamOut_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__StreamOut_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Describes the stream-out state in the PSO.\n"
		"\n"
		".. data:: NoRasterization\n"
		"\n"
		"  Value for :data:`rasterizedStream` that indicates no stream is being rasterized.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__StreamOut_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__StreamOut_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__StreamOut_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12StreamOut,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__StreamOut_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__StreamOut_type};

static SwigPyGetSet D3D12RasterizerState_depthBias_getset = { _wrap_D3D12RasterizerState_depthBias_get, _wrap_D3D12RasterizerState_depthBias_set };
static SwigPyGetSet D3D12RasterizerState_slopeScaledDepthBias_getset = { _wrap_D3D12RasterizerState_slopeScaledDepthBias_get, _wrap_D3D12RasterizerState_slopeScaledDepthBias_set };
static SwigPyGetSet D3D12RasterizerState_depthBiasClamp_getset = { _wrap_D3D12RasterizerState_depthBiasClamp_get, _wrap_D3D12RasterizerState_depthBiasClamp_set };
static SwigPyGetSet D3D12RasterizerState_fillMode_getset = { _wrap_D3D12RasterizerState_fillMode_get, _wrap_D3D12RasterizerState_fillMode_set };
static SwigPyGetSet D3D12RasterizerState_cullMode_getset = { _wrap_D3D12RasterizerState_cullMode_get, _wrap_D3D12RasterizerState_cullMode_set };
static SwigPyGetSet D3D12RasterizerState_depthClip_getset = { _wrap_D3D12RasterizerState_depthClip_get, _wrap_D3D12RasterizerState_depthClip_set };
static SwigPyGetSet D3D12RasterizerState_baseShadingRate_getset = { _wrap_D3D12RasterizerState_baseShadingRate_get, _wrap_D3D12RasterizerState_baseShadingRate_set };
static SwigPyGetSet D3D12RasterizerState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12RasterizerState_shadingRateCombiners_getset = { _wrap_D3D12RasterizerState_shadingRateCombiners_get, _wrap_D3D12RasterizerState_shadingRateCombiners_set };
static SwigPyGetSet D3D12RasterizerState_shadingRateImage_getset = { _wrap_D3D12RasterizerState_shadingRateImage_get, _wrap_D3D12RasterizerState_shadingRateImage_set };
static SwigPyGetSet D3D12RasterizerState_frontCCW_getset = { _wrap_D3D12RasterizerState_frontCCW_get, _wrap_D3D12RasterizerState_frontCCW_set };
static SwigPyGetSet D3D12RasterizerState_forcedSampleCount_getset = { _wrap_D3D12RasterizerState_forcedSampleCount_get, _wrap_D3D12RasterizerState_forcedSampleCount_set };
static SwigPyGetSet D3D12RasterizerState_lineRasterMode_getset = { _wrap_D3D12RasterizerState_lineRasterMode_get, _wrap_D3D12RasterizerState_lineRasterMode_set };
static SwigPyGetSet D3D12RasterizerState_conservativeRasterization_getset = { _wrap_D3D12RasterizerState_conservativeRasterization_get, _wrap_D3D12RasterizerState_conservativeRasterization_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__RasterizerState_getset[] = {
    { (char *) "depthBias", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed depth bias value to apply to z-values.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &D3D12RasterizerState_depthBias_getset }
,
    { (char *) "slopeScaledDepthBias", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The slope-scaled depth bias value to apply to z-values.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &D3D12RasterizerState_slopeScaledDepthBias_getset }
,
    { (char *) "depthBiasClamp", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The clamp value for calculated depth bias from :data:`depthBias` and\n"
		":data:`slopeScaledDepthBias`\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &D3D12RasterizerState_depthBiasClamp_getset }
,
    { (char *) "fillMode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The polygon :class:`FillMode`.\n"
		"\n"
		":type: FillMode\n"
		"\n"
		"", (void *) &D3D12RasterizerState_fillMode_getset }
,
    { (char *) "cullMode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The polygon :class:`CullMode`.\n"
		"\n"
		":type: CullMode\n"
		"\n"
		"", (void *) &D3D12RasterizerState_cullMode_getset }
,
    { (char *) "depthClip", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if pixels outside of the near and far depth planes should be clipped.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D12RasterizerState_depthClip_getset }
,
    { (char *) "baseShadingRate", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current base variable shading rate. This will always be 1x1 when variable shading\n"
		"is disabled.\n"
		"\n"
		":type: Tuple[int,int]\n"
		"\n"
		"", (void *) &D3D12RasterizerState_baseShadingRate_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::RasterizerState.__dict__", (void *) &D3D12RasterizerState___dict___getset }
,
    { (char *) "shadingRateCombiners", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The shading rate combiners.\n"
		"\n"
		"The combiners are applied as follows, according to the D3D spec:\n"
		"\n"
		"  ``intermediateRate = combiner[0] ( baseShadingRate,  shaderExportedShadingRate )``\n"
		"  ``finalRate        = combiner[1] ( intermediateRate, imageBasedShadingRate     )``\n"
		"\n"
		"Where the first input is from :data:`baseShadingRate` and the second is the exported shading rate\n"
		"from a vertex or geometry shader, which defaults to 1x1 if not exported.\n"
		"\n"
		"The intermediate result is then used as the first input to the second combiner, together with the\n"
		"shading rate sampled from the shading rate image.\n"
		"\n"
		":type: Tuple[ShadingRateCombiner,ShadingRateCombiner]\n"
		"\n"
		"", (void *) &D3D12RasterizerState_shadingRateCombiners_getset }
,
    { (char *) "shadingRateImage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The image bound as a shading rate image.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D12RasterizerState_shadingRateImage_getset }
,
    { (char *) "frontCCW", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if counter-clockwise polygons are front-facing.\n"
		"``False`` if clockwise polygons are front-facing.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D12RasterizerState_frontCCW_getset }
,
    { (char *) "forcedSampleCount", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A sample count to force rasterization to when UAV rendering or rasterizing, or 0 to\n"
		"not force any sample count.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12RasterizerState_forcedSampleCount_getset }
,
    { (char *) "lineRasterMode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The line rasterization mode.\n"
		"\n"
		":type: LineRaster\n"
		"\n"
		"", (void *) &D3D12RasterizerState_lineRasterMode_getset }
,
    { (char *) "conservativeRasterization", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current :class:`ConservativeRaster` mode.\n"
		"\n"
		":type: ConservativeRaster\n"
		"\n"
		"", (void *) &D3D12RasterizerState_conservativeRasterization_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__RasterizerState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__RasterizerState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__RasterizerState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12RasterizerState",         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12RasterizerState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__RasterizerState_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__RasterizerState_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__RasterizerState_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__RasterizerState_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the rasterizer state in the PSO.",                 /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__RasterizerState_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__RasterizerState_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__RasterizerState_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12RasterizerState,/* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__RasterizerState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__RasterizerState_type};

static SwigPyGetSet D3D12Rasterizer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12Rasterizer_sampleMask_getset = { _wrap_D3D12Rasterizer_sampleMask_get, _wrap_D3D12Rasterizer_sampleMask_set };
static SwigPyGetSet D3D12Rasterizer_scissors_getset = { _wrap_D3D12Rasterizer_scissors_get, _wrap_D3D12Rasterizer_scissors_set };
static SwigPyGetSet D3D12Rasterizer_state_getset = { _wrap_D3D12Rasterizer_state_get, _wrap_D3D12Rasterizer_state_set };
static SwigPyGetSet D3D12Rasterizer_viewports_getset = { _wrap_D3D12Rasterizer_viewports_get, _wrap_D3D12Rasterizer_viewports_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__Rasterizer_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::Rasterizer.__dict__", (void *) &D3D12Rasterizer___dict___getset }
,
    { (char *) "sampleMask", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The mask determining which samples are written to.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12Rasterizer_sampleMask_getset }
,
    { (char *) "scissors", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound scissor regions.\n"
		"\n"
		":type: List[Scissor]\n"
		"\n"
		"", (void *) &D3D12Rasterizer_scissors_getset }
,
    { (char *) "state", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The details of the rasterization state.\n"
		"\n"
		":type: D3D12RasterizerState\n"
		"\n"
		"", (void *) &D3D12Rasterizer_state_getset }
,
    { (char *) "viewports", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound viewports.\n"
		"\n"
		":type: List[Viewport]\n"
		"\n"
		"", (void *) &D3D12Rasterizer_viewports_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__Rasterizer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__Rasterizer_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__Rasterizer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12Rasterizer",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12Rasterizer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__Rasterizer_type.as_number,         /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__Rasterizer_type.as_sequence,       /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__Rasterizer_type.as_mapping,        /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__Rasterizer_type.as_buffer,         /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the rasterization state of the D3D12 pipeline.",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__Rasterizer_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__Rasterizer_methods,                 /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__Rasterizer_getset,                  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12Rasterizer,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__Rasterizer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__Rasterizer_type};

static SwigPyGetSet D3D12DepthStencilState_frontFace_getset = { _wrap_D3D12DepthStencilState_frontFace_get, _wrap_D3D12DepthStencilState_frontFace_set };
static SwigPyGetSet D3D12DepthStencilState_backFace_getset = { _wrap_D3D12DepthStencilState_backFace_get, _wrap_D3D12DepthStencilState_backFace_set };
static SwigPyGetSet D3D12DepthStencilState_depthFunction_getset = { _wrap_D3D12DepthStencilState_depthFunction_get, _wrap_D3D12DepthStencilState_depthFunction_set };
static SwigPyGetSet D3D12DepthStencilState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12DepthStencilState_depthBoundsEnable_getset = { _wrap_D3D12DepthStencilState_depthBoundsEnable_get, _wrap_D3D12DepthStencilState_depthBoundsEnable_set };
static SwigPyGetSet D3D12DepthStencilState_minDepthBounds_getset = { _wrap_D3D12DepthStencilState_minDepthBounds_get, _wrap_D3D12DepthStencilState_minDepthBounds_set };
static SwigPyGetSet D3D12DepthStencilState_maxDepthBounds_getset = { _wrap_D3D12DepthStencilState_maxDepthBounds_get, _wrap_D3D12DepthStencilState_maxDepthBounds_set };
static SwigPyGetSet D3D12DepthStencilState_depthEnable_getset = { _wrap_D3D12DepthStencilState_depthEnable_get, _wrap_D3D12DepthStencilState_depthEnable_set };
static SwigPyGetSet D3D12DepthStencilState_depthWrites_getset = { _wrap_D3D12DepthStencilState_depthWrites_get, _wrap_D3D12DepthStencilState_depthWrites_set };
static SwigPyGetSet D3D12DepthStencilState_stencilEnable_getset = { _wrap_D3D12DepthStencilState_stencilEnable_get, _wrap_D3D12DepthStencilState_stencilEnable_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__DepthStencilState_getset[] = {
    { (char *) "frontFace", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stencil state for front-facing polygons.\n"
		"\n"
		":type: StencilFace\n"
		"\n"
		"", (void *) &D3D12DepthStencilState_frontFace_getset }
,
    { (char *) "backFace", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stencil state for back-facing polygons.\n"
		"\n"
		":type: StencilFace\n"
		"\n"
		"", (void *) &D3D12DepthStencilState_backFace_getset }
,
    { (char *) "depthFunction", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`CompareFunction` to use for testing depth values.\n"
		"\n"
		":type: CompareFunction\n"
		"\n"
		"", (void *) &D3D12DepthStencilState_depthFunction_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::DepthStencilState.__dict__", (void *) &D3D12DepthStencilState___dict___getset }
,
    { (char *) "depthBoundsEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth bounds tests should be applied.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D12DepthStencilState_depthBoundsEnable_getset }
,
    { (char *) "minDepthBounds", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The near plane bounding value.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &D3D12DepthStencilState_minDepthBounds_getset }
,
    { (char *) "maxDepthBounds", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The far plane bounding value.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &D3D12DepthStencilState_maxDepthBounds_getset }
,
    { (char *) "depthEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth testing should be performed.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D12DepthStencilState_depthEnable_getset }
,
    { (char *) "depthWrites", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth values should be written to the depth target.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D12DepthStencilState_depthWrites_getset }
,
    { (char *) "stencilEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if stencil operations should be performed.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D12DepthStencilState_stencilEnable_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__DepthStencilState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__DepthStencilState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__DepthStencilState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12DepthStencilState",       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12DepthStencilState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__DepthStencilState_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__DepthStencilState_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__DepthStencilState_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__DepthStencilState_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the state of the depth-stencil state in the PSO.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__DepthStencilState_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__DepthStencilState_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__DepthStencilState_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12DepthStencilState,                  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__DepthStencilState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__DepthStencilState_type};

static SwigPyGetSet D3D12BlendState_blends_getset = { _wrap_D3D12BlendState_blends_get, _wrap_D3D12BlendState_blends_set };
static SwigPyGetSet D3D12BlendState_independentBlend_getset = { _wrap_D3D12BlendState_independentBlend_get, _wrap_D3D12BlendState_independentBlend_set };
static SwigPyGetSet D3D12BlendState_blendFactor_getset = { _wrap_D3D12BlendState_blendFactor_get, _wrap_D3D12BlendState_blendFactor_set };
static SwigPyGetSet D3D12BlendState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12BlendState_alphaToCoverage_getset = { _wrap_D3D12BlendState_alphaToCoverage_get, _wrap_D3D12BlendState_alphaToCoverage_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__BlendState_getset[] = {
    { (char *) "blends", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The blend operations for each target.\n"
		"\n"
		":type: List[ColorBlend]\n"
		"\n"
		"", (void *) &D3D12BlendState_blends_getset }
,
    { (char *) "independentBlend", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if independent blending for each target should be used.\n"
		"\n"
		"``False`` if the first blend should be applied to all targets.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D12BlendState_independentBlend_getset }
,
    { (char *) "blendFactor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The constant blend factor to use in blend equations.\n"
		"\n"
		":type: Tuple[float,float,float,float]\n"
		"\n"
		"", (void *) &D3D12BlendState_blendFactor_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::BlendState.__dict__", (void *) &D3D12BlendState___dict___getset }
,
    { (char *) "alphaToCoverage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if alpha-to-coverage should be used when blending to an MSAA target.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D12BlendState_alphaToCoverage_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__BlendState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__BlendState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__BlendState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12BlendState",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12BlendState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__BlendState_type.as_number,         /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__BlendState_type.as_sequence,       /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__BlendState_type.as_mapping,        /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__BlendState_type.as_buffer,         /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the blend state in the PSO.",  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__BlendState_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__BlendState_methods,                 /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__BlendState_getset,                  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12BlendState,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__BlendState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__BlendState_type};

static SwigPyGetSet D3D12OM_depthStencilState_getset = { _wrap_D3D12OM_depthStencilState_get, _wrap_D3D12OM_depthStencilState_set };
static SwigPyGetSet D3D12OM_depthTarget_getset = { _wrap_D3D12OM_depthTarget_get, _wrap_D3D12OM_depthTarget_set };
static SwigPyGetSet D3D12OM_depthReadOnly_getset = { _wrap_D3D12OM_depthReadOnly_get, _wrap_D3D12OM_depthReadOnly_set };
static SwigPyGetSet D3D12OM_stencilReadOnly_getset = { _wrap_D3D12OM_stencilReadOnly_get, _wrap_D3D12OM_stencilReadOnly_set };
static SwigPyGetSet D3D12OM___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12OM_renderTargets_getset = { _wrap_D3D12OM_renderTargets_get, _wrap_D3D12OM_renderTargets_set };
static SwigPyGetSet D3D12OM_blendState_getset = { _wrap_D3D12OM_blendState_get, _wrap_D3D12OM_blendState_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__OM_getset[] = {
    { (char *) "depthStencilState", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current depth-stencil state details.\n"
		"\n"
		":type: D3D12DepthStencilState\n"
		"\n"
		"", (void *) &D3D12OM_depthStencilState_getset }
,
    { (char *) "depthTarget", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The currently bound depth-stencil target.\n"
		"\n"
		":type: Descriptor\n"
		"\n"
		"", (void *) &D3D12OM_depthTarget_getset }
,
    { (char *) "depthReadOnly", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth access to the depth-stencil target is read-only.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D12OM_depthReadOnly_getset }
,
    { (char *) "stencilReadOnly", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if stenncil access to the depth-stencil target is read-only.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D12OM_stencilReadOnly_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::OM.__dict__", (void *) &D3D12OM___dict___getset }
,
    { (char *) "renderTargets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound render targets.\n"
		"\n"
		":type: List[Descriptor]\n"
		"\n"
		"", (void *) &D3D12OM_renderTargets_getset }
,
    { (char *) "blendState", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current blend state details.\n"
		"\n"
		":type: D3D12BlendState\n"
		"\n"
		"", (void *) &D3D12OM_blendState_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__OM_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__OM_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__OM_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12OM",                      /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12OM_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__OM_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__OM_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__OM_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__OM_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the current state of the output-merger stage of the D3D12 pipeline.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__OM_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__OM_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__OM_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12OM,             /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__OM_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__OM_type};

static SwigPyGetSet D3D12ResourceState_name_getset = { _wrap_D3D12ResourceState_name_get, _wrap_D3D12ResourceState_name_set };
static SwigPyGetSet D3D12ResourceState___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__ResourceState_getset[] = {
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A human-readable name for the current state.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &D3D12ResourceState_name_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::ResourceState.__dict__", (void *) &D3D12ResourceState___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__ResourceState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_D3D12ResourceState___eq__(self, other); break;
    case Py_LT : result = _wrap_D3D12ResourceState___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__ResourceState_methods[] = {
  { "__eq__", (PyCFunction) _wrap_D3D12ResourceState___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_D3D12ResourceState___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__ResourceState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12ResourceState",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12ResourceState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__ResourceState_type.as_number,      /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__ResourceState_type.as_sequence,    /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__ResourceState_type.as_mapping,     /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__ResourceState_type.as_buffer,      /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the current state that a sub-resource is in.",     /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__ResourceState_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__ResourceState_methods,              /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__ResourceState_getset,               /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12ResourceState,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__ResourceState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__ResourceState_type};

static SwigPyGetSet D3D12ResourceData_resourceId_getset = { _wrap_D3D12ResourceData_resourceId_get, _wrap_D3D12ResourceData_resourceId_set };
static SwigPyGetSet D3D12ResourceData___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12ResourceData_states_getset = { _wrap_D3D12ResourceData_states_get, _wrap_D3D12ResourceData_states_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__ResourceData_getset[] = {
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the resource.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D12ResourceData_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::ResourceData.__dict__", (void *) &D3D12ResourceData___dict___getset }
,
    { (char *) "states", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The subresource states in this resource.\n"
		"\n"
		":type: List[D3D12ResourceState]\n"
		"\n"
		"", (void *) &D3D12ResourceData_states_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__ResourceData_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_D3D12ResourceData___eq__(self, other); break;
    case Py_LT : result = _wrap_D3D12ResourceData___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__ResourceData_methods[] = {
  { "__eq__", (PyCFunction) _wrap_D3D12ResourceData___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_D3D12ResourceData___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__ResourceData_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12ResourceData",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12ResourceData_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__ResourceData_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__ResourceData_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__ResourceData_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__ResourceData_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the current state of a given resource.",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__ResourceData_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__ResourceData_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__ResourceData_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12ResourceData,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__ResourceData_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__ResourceData_type};

static SwigPyGetSet D3D12RootTableRange_count_getset = { _wrap_D3D12RootTableRange_count_get, _wrap_D3D12RootTableRange_count_set };
static SwigPyGetSet D3D12RootTableRange___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12RootTableRange_appended_getset = { _wrap_D3D12RootTableRange_appended_get, _wrap_D3D12RootTableRange_appended_set };
static SwigPyGetSet D3D12RootTableRange_tableByteOffset_getset = { _wrap_D3D12RootTableRange_tableByteOffset_get, _wrap_D3D12RootTableRange_tableByteOffset_set };
static SwigPyGetSet D3D12RootTableRange_space_getset = { _wrap_D3D12RootTableRange_space_get, _wrap_D3D12RootTableRange_space_set };
static SwigPyGetSet D3D12RootTableRange_baseRegister_getset = { _wrap_D3D12RootTableRange_baseRegister_get, _wrap_D3D12RootTableRange_baseRegister_set };
static SwigPyGetSet D3D12RootTableRange_category_getset = { _wrap_D3D12RootTableRange_category_get, _wrap_D3D12RootTableRange_category_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__RootTableRange_getset[] = {
    { (char *) "count", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of registers in this range.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12RootTableRange_count_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::RootTableRange.__dict__", (void *) &D3D12RootTableRange___dict___getset }
,
    { (char *) "appended", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Whether or not this table was appended after the previous, leading to an auto-calculated\n"
		"offset in :data:`tableByteOffset`.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D12RootTableRange_appended_getset }
,
    { (char *) "tableByteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in bytes from the start of the table as defined in :class:`D3D12RootParam`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12RootTableRange_tableByteOffset_getset }
,
    { (char *) "space", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The register space of this range.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12RootTableRange_space_getset }
,
    { (char *) "baseRegister", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The first register in this range.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12RootTableRange_baseRegister_getset }
,
    { (char *) "category", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The descriptor category specified in this range.\n"
		"\n"
		":type: DescriptorCategory\n"
		"\n"
		"", (void *) &D3D12RootTableRange_category_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__RootTableRange_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_D3D12RootTableRange___eq__(self, other); break;
    case Py_LT : result = _wrap_D3D12RootTableRange___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__RootTableRange_methods[] = {
  { "__eq__", (PyCFunction) _wrap_D3D12RootTableRange___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_D3D12RootTableRange___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__RootTableRange_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12RootTableRange",          /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12RootTableRange_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__RootTableRange_type.as_number,     /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__RootTableRange_type.as_sequence,   /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__RootTableRange_type.as_mapping,    /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__RootTableRange_type.as_buffer,     /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the structure of a single range within a root table definition.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__RootTableRange_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__RootTableRange_methods,             /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__RootTableRange_getset,              /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12RootTableRange, /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__RootTableRange_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__RootTableRange_type};

static SwigPyGetSet D3D12RootParam_reg_getset = { _wrap_D3D12RootParam_reg_get, _wrap_D3D12RootParam_reg_set };
static SwigPyGetSet D3D12RootParam_heap_getset = { _wrap_D3D12RootParam_heap_get, _wrap_D3D12RootParam_heap_set };
static SwigPyGetSet D3D12RootParam_descriptor_getset = { _wrap_D3D12RootParam_descriptor_get, _wrap_D3D12RootParam_descriptor_set };
static SwigPyGetSet D3D12RootParam___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12RootParam_visibility_getset = { _wrap_D3D12RootParam_visibility_get, _wrap_D3D12RootParam_visibility_set };
static SwigPyGetSet D3D12RootParam_constants_getset = { _wrap_D3D12RootParam_constants_get, _wrap_D3D12RootParam_constants_set };
static SwigPyGetSet D3D12RootParam_heapByteOffset_getset = { _wrap_D3D12RootParam_heapByteOffset_get, _wrap_D3D12RootParam_heapByteOffset_set };
static SwigPyGetSet D3D12RootParam_tableRanges_getset = { _wrap_D3D12RootParam_tableRanges_get, _wrap_D3D12RootParam_tableRanges_set };
static SwigPyGetSet D3D12RootParam_space_getset = { _wrap_D3D12RootParam_space_get, _wrap_D3D12RootParam_space_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__RootParam_getset[] = {
    { (char *) "reg", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For a root parameter, the register of the binding.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12RootParam_reg_getset }
,
    { (char *) "heap", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For a root table parameter, the descriptor heap bound to this parameter. See\n"
		":data:`heapByteOffset` and :data:`tableRanges`.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D12RootParam_heap_getset }
,
    { (char *) "descriptor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For a root descriptor parameter, the descriptor itself.\n"
		"\n"
		":type: Descriptor\n"
		"\n"
		"", (void *) &D3D12RootParam_descriptor_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::RootParam.__dict__", (void *) &D3D12RootParam___dict___getset }
,
    { (char *) "visibility", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The shader stage that can access this parameter.\n"
		"\n"
		":type: ShaderStageMask\n"
		"\n"
		"", (void *) &D3D12RootParam_visibility_getset }
,
    { (char *) "constants", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For a root constant parameter, the words defined.\n"
		"\n"
		":type: bytes\n"
		"\n"
		"", (void *) &D3D12RootParam_constants_getset }
,
    { (char *) "heapByteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For a root table parameter, the byte offset into the descriptor heap bound to this\n"
		"parameter. See :data:`heap` and :data:`tableRanges`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12RootParam_heapByteOffset_getset }
,
    { (char *) "tableRanges", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For a root table parameter, the descriptor ranges that define this table. See\n"
		":data:`heap` and :data:`heapByteOffset`.\n"
		"\n"
		":type: List[D3D12RootTableRange]\n"
		"\n"
		"", (void *) &D3D12RootParam_tableRanges_getset }
,
    { (char *) "space", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For a root parameter, the register space of the binding.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12RootParam_space_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__RootParam_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_D3D12RootParam___eq__(self, other); break;
    case Py_LT : result = _wrap_D3D12RootParam___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__RootParam_methods[] = {
  { "__eq__", (PyCFunction) _wrap_D3D12RootParam___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_D3D12RootParam___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__RootParam_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12RootParam",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12RootParam_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__RootParam_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__RootParam_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__RootParam_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__RootParam_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the structure and content of a single root parameter.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__RootParam_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__RootParam_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__RootParam_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12RootParam,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__RootParam_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__RootParam_type};

static SwigPyGetSet D3D12StaticSampler_reg_getset = { _wrap_D3D12StaticSampler_reg_get, _wrap_D3D12StaticSampler_reg_set };
static SwigPyGetSet D3D12StaticSampler_descriptor_getset = { _wrap_D3D12StaticSampler_descriptor_get, _wrap_D3D12StaticSampler_descriptor_set };
static SwigPyGetSet D3D12StaticSampler___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12StaticSampler_visibility_getset = { _wrap_D3D12StaticSampler_visibility_get, _wrap_D3D12StaticSampler_visibility_set };
static SwigPyGetSet D3D12StaticSampler_space_getset = { _wrap_D3D12StaticSampler_space_get, _wrap_D3D12StaticSampler_space_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__StaticSampler_getset[] = {
    { (char *) "reg", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The register number of this sampler.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12StaticSampler_reg_getset }
,
    { (char *) "descriptor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The details of the sampler descriptor itself.\n"
		"\n"
		":type: SamplerDescriptor\n"
		"\n"
		"", (void *) &D3D12StaticSampler_descriptor_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::StaticSampler.__dict__", (void *) &D3D12StaticSampler___dict___getset }
,
    { (char *) "visibility", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The shader stage that can access this sampler.\n"
		"\n"
		":type: ShaderStageMask\n"
		"\n"
		"", (void *) &D3D12StaticSampler_visibility_getset }
,
    { (char *) "space", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The register space of this sampler.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12StaticSampler_space_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__StaticSampler_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_D3D12StaticSampler___eq__(self, other); break;
    case Py_LT : result = _wrap_D3D12StaticSampler___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__StaticSampler_methods[] = {
  { "__eq__", (PyCFunction) _wrap_D3D12StaticSampler___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_D3D12StaticSampler___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__StaticSampler_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12StaticSampler",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12StaticSampler_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__StaticSampler_type.as_number,      /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__StaticSampler_type.as_sequence,    /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__StaticSampler_type.as_mapping,     /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__StaticSampler_type.as_buffer,      /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the details of a single static sampler in a root signature.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__StaticSampler_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__StaticSampler_methods,              /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__StaticSampler_getset,               /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12StaticSampler,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__StaticSampler_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__StaticSampler_type};

static SwigPyGetSet D3D12RootSignature_parameters_getset = { _wrap_D3D12RootSignature_parameters_get, _wrap_D3D12RootSignature_parameters_set };
static SwigPyGetSet D3D12RootSignature_resourceId_getset = { _wrap_D3D12RootSignature_resourceId_get, _wrap_D3D12RootSignature_resourceId_set };
static SwigPyGetSet D3D12RootSignature_staticSamplers_getset = { _wrap_D3D12RootSignature_staticSamplers_get, _wrap_D3D12RootSignature_staticSamplers_set };
static SwigPyGetSet D3D12RootSignature___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__RootSignature_getset[] = {
    { (char *) "parameters", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The parameters in this root signature.\n"
		"\n"
		":type: List[D3D12RootParam]\n"
		"\n"
		"", (void *) &D3D12RootSignature_parameters_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the root signature object.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D12RootSignature_resourceId_getset }
,
    { (char *) "staticSamplers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The static samplers defined in this root signature.\n"
		"\n"
		":type: List[D3D12StaticSampler]\n"
		"\n"
		"", (void *) &D3D12RootSignature_staticSamplers_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::RootSignature.__dict__", (void *) &D3D12RootSignature___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__RootSignature_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__RootSignature_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__RootSignature_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12RootSignature",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12RootSignature_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__RootSignature_type.as_number,      /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__RootSignature_type.as_sequence,    /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__RootSignature_type.as_mapping,     /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__RootSignature_type.as_buffer,      /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the root signature structure and root parameters.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__RootSignature_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__RootSignature_methods,              /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__RootSignature_getset,               /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12RootSignature,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__RootSignature_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__RootSignature_type};

static SwigPyGetSet D3D12Predication_resourceId_getset = { _wrap_D3D12Predication_resourceId_get, _wrap_D3D12Predication_resourceId_set };
static SwigPyGetSet D3D12Predication___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12Predication_offset_getset = { _wrap_D3D12Predication_offset_get, _wrap_D3D12Predication_offset_set };
static SwigPyGetSet D3D12Predication_skipIfZero_getset = { _wrap_D3D12Predication_skipIfZero_get, _wrap_D3D12Predication_skipIfZero_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__Predication_getset[] = {
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the buffer used for predicate data.\n"
		"\n"
		"If this is unset, predication is not enabled.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D12Predication_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::Predication.__dict__", (void *) &D3D12Predication___dict___getset }
,
    { (char *) "offset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in the buffer where the value is read.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &D3D12Predication_offset_getset }
,
    { (char *) "skipIfZero", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if a value of zero in the buffer would lead to draws/dispatches being skipped when\n"
		"predication is enabled.\n"
		"\n"
		"If ``False`` then a zero in the buffer would lead to them being performed as normal.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &D3D12Predication_skipIfZero_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__Predication_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__Predication_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__Predication_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12Predication",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12Predication_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__Predication_type.as_number,        /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__Predication_type.as_sequence,      /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__Predication_type.as_mapping,       /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__Predication_type.as_buffer,        /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the current state of D3D12 predicated rendering.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__Predication_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__Predication_methods,                /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__Predication_getset,                 /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_D3D12Predication,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__Predication_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__Predication_type};

static SwigPyGetSet D3D12State_streamOut_getset = { _wrap_D3D12State_streamOut_get, _wrap_D3D12State_streamOut_set };
static SwigPyGetSet D3D12State_outputMerger_getset = { _wrap_D3D12State_outputMerger_get, _wrap_D3D12State_outputMerger_set };
static SwigPyGetSet D3D12State_predication_getset = { _wrap_D3D12State_predication_get, _wrap_D3D12State_predication_set };
static SwigPyGetSet D3D12State_pipelineResourceId_getset = { _wrap_D3D12State_pipelineResourceId_get, _wrap_D3D12State_pipelineResourceId_set };
static SwigPyGetSet D3D12State___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet D3D12State_rootSignature_getset = { _wrap_D3D12State_rootSignature_get, _wrap_D3D12State_rootSignature_set };
static SwigPyGetSet D3D12State_inputAssembly_getset = { _wrap_D3D12State_inputAssembly_get, _wrap_D3D12State_inputAssembly_set };
static SwigPyGetSet D3D12State_geometryShader_getset = { _wrap_D3D12State_geometryShader_get, _wrap_D3D12State_geometryShader_set };
static SwigPyGetSet D3D12State_computeShader_getset = { _wrap_D3D12State_computeShader_get, _wrap_D3D12State_computeShader_set };
static SwigPyGetSet D3D12State_resourceStates_getset = { _wrap_D3D12State_resourceStates_get, _wrap_D3D12State_resourceStates_set };
static SwigPyGetSet D3D12State_descriptorHeaps_getset = { _wrap_D3D12State_descriptorHeaps_get, _wrap_D3D12State_descriptorHeaps_set };
static SwigPyGetSet D3D12State_rasterizer_getset = { _wrap_D3D12State_rasterizer_get, _wrap_D3D12State_rasterizer_set };
static SwigPyGetSet D3D12State_vertexShader_getset = { _wrap_D3D12State_vertexShader_get, _wrap_D3D12State_vertexShader_set };
static SwigPyGetSet D3D12State_hullShader_getset = { _wrap_D3D12State_hullShader_get, _wrap_D3D12State_hullShader_set };
static SwigPyGetSet D3D12State_domainShader_getset = { _wrap_D3D12State_domainShader_get, _wrap_D3D12State_domainShader_set };
static SwigPyGetSet D3D12State_pixelShader_getset = { _wrap_D3D12State_pixelShader_get, _wrap_D3D12State_pixelShader_set };
static SwigPyGetSet D3D12State_ampShader_getset = { _wrap_D3D12State_ampShader_get, _wrap_D3D12State_ampShader_set };
static SwigPyGetSet D3D12State_meshShader_getset = { _wrap_D3D12State_meshShader_get, _wrap_D3D12State_meshShader_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__D3D12Pipe__State_getset[] = {
    { (char *) "streamOut", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stream-out pipeline stage.\n"
		"\n"
		":type: D3D12StreamOut\n"
		"\n"
		"", (void *) &D3D12State_streamOut_getset }
,
    { (char *) "outputMerger", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The output merger pipeline stage.\n"
		"\n"
		":type: D3D12OM\n"
		"\n"
		"", (void *) &D3D12State_outputMerger_getset }
,
    { (char *) "predication", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The predicated rendering state.\n"
		"\n"
		":type: D3D12Predication\n"
		"\n"
		"", (void *) &D3D12State_predication_getset }
,
    { (char *) "pipelineResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the pipeline state object.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &D3D12State_pipelineResourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"D3D12Pipe::State.__dict__", (void *) &D3D12State___dict___getset }
,
    { (char *) "rootSignature", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Details of the root signature structure and root parameters.\n"
		"\n"
		":type: D3D12RootSignature\n"
		"\n"
		"", (void *) &D3D12State_rootSignature_getset }
,
    { (char *) "inputAssembly", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The input assembly pipeline stage.\n"
		"\n"
		":type: D3D12InputAssembly\n"
		"\n"
		"", (void *) &D3D12State_inputAssembly_getset }
,
    { (char *) "geometryShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The geometry shader stage.\n"
		"\n"
		":type: D3D12Shader\n"
		"\n"
		"", (void *) &D3D12State_geometryShader_getset }
,
    { (char *) "computeShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The compute shader stage.\n"
		"\n"
		":type: D3D12Shader\n"
		"\n"
		"", (void *) &D3D12State_computeShader_getset }
,
    { (char *) "resourceStates", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The resource states for the currently live resources.\n"
		"\n"
		":type: List[D3D12ResourceData]\n"
		"\n"
		"", (void *) &D3D12State_resourceStates_getset }
,
    { (char *) "descriptorHeaps", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The descriptor heaps currently bound.\n"
		"\n"
		":type: List[ResourceId]\n"
		"\n"
		"", (void *) &D3D12State_descriptorHeaps_getset }
,
    { (char *) "rasterizer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The rasterizer pipeline stage.\n"
		"\n"
		":type: D3D12Rasterizer\n"
		"\n"
		"", (void *) &D3D12State_rasterizer_getset }
,
    { (char *) "vertexShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex shader stage.\n"
		"\n"
		":type: D3D12Shader\n"
		"\n"
		"", (void *) &D3D12State_vertexShader_getset }
,
    { (char *) "hullShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The hull shader stage.\n"
		"\n"
		":type: D3D12Shader\n"
		"\n"
		"", (void *) &D3D12State_hullShader_getset }
,
    { (char *) "domainShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The domain shader stage.\n"
		"\n"
		":type: D3D12Shader\n"
		"\n"
		"", (void *) &D3D12State_domainShader_getset }
,
    { (char *) "pixelShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The pixel shader stage.\n"
		"\n"
		":type: D3D12Shader\n"
		"\n"
		"", (void *) &D3D12State_pixelShader_getset }
,
    { (char *) "ampShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The amplification shader stage.\n"
		"\n"
		":type: D3D12Shader\n"
		"\n"
		"", (void *) &D3D12State_ampShader_getset }
,
    { (char *) "meshShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The mesh shader stage.\n"
		"\n"
		":type: D3D12Shader\n"
		"\n"
		"", (void *) &D3D12State_meshShader_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__D3D12Pipe__State_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__D3D12Pipe__State_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__D3D12Pipe__State_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.D3D12State",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_D3D12State_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__D3D12Pipe__State_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__D3D12Pipe__State_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__D3D12Pipe__State_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__D3D12Pipe__State_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The full current D3D12 pipeline state.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__D3D12Pipe__State_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__D3D12Pipe__State_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__D3D12Pipe__State_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__D3D12Pipe__State_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__State_type};

static SwigPyGetSet FloatVector_w_getset = { _wrap_FloatVector_w_get, _wrap_FloatVector_w_set };
static SwigPyGetSet FloatVector_x_getset = { _wrap_FloatVector_x_get, _wrap_FloatVector_x_set };
static SwigPyGetSet FloatVector_y_getset = { _wrap_FloatVector_y_get, _wrap_FloatVector_y_set };
static SwigPyGetSet FloatVector_z_getset = { _wrap_FloatVector_z_get, _wrap_FloatVector_z_set };
static SwigPyGetSet FloatVector___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__FloatVector_getset[] = {
    { (char *) "w", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The w component.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &FloatVector_w_getset }
,
    { (char *) "x", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The x component.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &FloatVector_x_getset }
,
    { (char *) "y", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The y component.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &FloatVector_y_getset }
,
    { (char *) "z", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The z component.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &FloatVector_z_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"FloatVector.__dict__", (void *) &FloatVector___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__FloatVector_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_FloatVector___eq__(self, other); break;
    case Py_NE : result = _wrap_FloatVector___ne__(self, other); break;
    case Py_LT : result = _wrap_FloatVector___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__FloatVector_methods[] = {
  { "__eq__", (PyCFunction) _wrap_FloatVector___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_FloatVector___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_FloatVector___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__FloatVector_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.FloatVector",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_FloatVector_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__FloatVector_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__FloatVector_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__FloatVector_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__FloatVector_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A floating point four-component vector", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__FloatVector_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__FloatVector_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__FloatVector_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_FloatVector,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__FloatVector_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__FloatVector_type};

static SwigPyGetSet AxisMapping_xAxis_getset = { _wrap_AxisMapping_xAxis_get, _wrap_AxisMapping_xAxis_set };
static SwigPyGetSet AxisMapping___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet AxisMapping_zAxis_getset = { _wrap_AxisMapping_zAxis_get, _wrap_AxisMapping_zAxis_set };
static SwigPyGetSet AxisMapping_yAxis_getset = { _wrap_AxisMapping_yAxis_get, _wrap_AxisMapping_yAxis_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__AxisMapping_getset[] = {
    { (char *) "xAxis", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The mapping of the x axis.\n"
		"\n"
		":type: FloatVector\n"
		"\n"
		"", (void *) &AxisMapping_xAxis_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"AxisMapping.__dict__", (void *) &AxisMapping___dict___getset }
,
    { (char *) "zAxis", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The mapping of the z axis.\n"
		"\n"
		":type: FloatVector\n"
		"\n"
		"", (void *) &AxisMapping_zAxis_getset }
,
    { (char *) "yAxis", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The mapping of the y axis.\n"
		"\n"
		":type: FloatVector\n"
		"\n"
		"", (void *) &AxisMapping_yAxis_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__AxisMapping_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__AxisMapping_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__AxisMapping_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.AxisMapping",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_AxisMapping_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__AxisMapping_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__AxisMapping_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__AxisMapping_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__AxisMapping_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A transform to map the x, y, and z axes to new directions.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__AxisMapping_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__AxisMapping_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__AxisMapping_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_AxisMapping,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__AxisMapping_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__AxisMapping_type};

static SwigPyGetSet PathEntry_lastmod_getset = { _wrap_PathEntry_lastmod_get, _wrap_PathEntry_lastmod_set };
static SwigPyGetSet PathEntry_size_getset = { _wrap_PathEntry_size_get, _wrap_PathEntry_size_set };
static SwigPyGetSet PathEntry___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet PathEntry_filename_getset = { _wrap_PathEntry_filename_get, _wrap_PathEntry_filename_set };
static SwigPyGetSet PathEntry_flags_getset = { _wrap_PathEntry_flags_get, _wrap_PathEntry_flags_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__PathEntry_getset[] = {
    { (char *) "lastmod", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The last modified date of this path, as a unix timestamp in UTC.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &PathEntry_lastmod_getset }
,
    { (char *) "size", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size of the path in bytes.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &PathEntry_size_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"PathEntry.__dict__", (void *) &PathEntry___dict___getset }
,
    { (char *) "filename", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The filename of this path. This contains only the filename, not the full path.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &PathEntry_filename_getset }
,
    { (char *) "flags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`PathProperty` flags for this path.\n"
		"\n"
		":type: PathProperty\n"
		"\n"
		"", (void *) &PathEntry_flags_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__PathEntry_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_PathEntry___eq__(self, other); break;
    case Py_LT : result = _wrap_PathEntry___lt__(self, other); break;
    case Py_NE : result = _wrap_PathEntry___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__PathEntry_methods[] = {
  { "__lt__", (PyCFunction) _wrap_PathEntry___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_PathEntry___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_PathEntry___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__PathEntry_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.PathEntry",                    /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_PathEntry_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__PathEntry_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__PathEntry_type.as_sequence,                   /* tp_as_sequence */
    &SwigPyBuiltin__PathEntry_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__PathEntry_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Properties of a path on a remote filesystem.",               /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__PathEntry_richcompare,           /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__PathEntry_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__PathEntry_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_PathEntry,           /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__PathEntry_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__PathEntry_type};

static SwigPyGetSet SectionProperties_name_getset = { _wrap_SectionProperties_name_get, _wrap_SectionProperties_name_set };
static SwigPyGetSet SectionProperties___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet SectionProperties_type_getset = { _wrap_SectionProperties_type_get, _wrap_SectionProperties_type_set };
static SwigPyGetSet SectionProperties_flags_getset = { _wrap_SectionProperties_flags_get, _wrap_SectionProperties_flags_set };
static SwigPyGetSet SectionProperties_version_getset = { _wrap_SectionProperties_version_get, _wrap_SectionProperties_version_set };
static SwigPyGetSet SectionProperties_uncompressedSize_getset = { _wrap_SectionProperties_uncompressedSize_get, _wrap_SectionProperties_uncompressedSize_set };
static SwigPyGetSet SectionProperties_compressedSize_getset = { _wrap_SectionProperties_compressedSize_get, _wrap_SectionProperties_compressedSize_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SectionProperties_getset[] = {
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of this section.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &SectionProperties_name_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SectionProperties.__dict__", (void *) &SectionProperties___dict___getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The type of this section, if it is a known pre-defined section.\n"
		"\n"
		":type: SectionType\n"
		"\n"
		"", (void *) &SectionProperties_type_getset }
,
    { (char *) "flags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The flags describing how this section is stored.\n"
		"\n"
		":type: SectionFlags\n"
		"\n"
		"", (void *) &SectionProperties_flags_getset }
,
    { (char *) "version", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The version of this section - the meaning of which is up to the type.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SectionProperties_version_getset }
,
    { (char *) "uncompressedSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of bytes of data contained in this section, once uncompressed.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SectionProperties_uncompressedSize_getset }
,
    { (char *) "compressedSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of bytes of data in this section when compressed on disk.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SectionProperties_compressedSize_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SectionProperties_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SectionProperties_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SectionProperties_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.SectionProperties",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_SectionProperties_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SectionProperties_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__SectionProperties_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__SectionProperties_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SectionProperties_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Properties of a section in a renderdoc capture file.",       /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SectionProperties_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SectionProperties_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SectionProperties_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_SectionProperties,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SectionProperties_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SectionProperties_type};

static SwigPyGetSet ResourceFormat_compCount_getset = { _wrap_ResourceFormat_compCount_get, _wrap_ResourceFormat_compCount_set };
static SwigPyGetSet ResourceFormat___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ResourceFormat_type_getset = { _wrap_ResourceFormat_type_get, _wrap_ResourceFormat_type_set };
static SwigPyGetSet ResourceFormat_compType_getset = { _wrap_ResourceFormat_compType_get, _wrap_ResourceFormat_compType_set };
static SwigPyGetSet ResourceFormat_compByteWidth_getset = { _wrap_ResourceFormat_compByteWidth_get, _wrap_ResourceFormat_compByteWidth_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ResourceFormat_getset[] = {
    { (char *) "compCount", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of components in each element.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ResourceFormat_compCount_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ResourceFormat.__dict__", (void *) &ResourceFormat___dict___getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceFormatType` of this format. If the value is not\n"
		":attr:`ResourceFormatType.Regular` then it's a non-uniform layout like block-compressed.\n"
		"\n"
		":type: ResourceFormatType\n"
		"\n"
		"", (void *) &ResourceFormat_type_getset }
,
    { (char *) "compType", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`type <CompType>` of each component.\n"
		"\n"
		":type: CompType\n"
		"\n"
		"", (void *) &ResourceFormat_compType_getset }
,
    { (char *) "compByteWidth", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The width in bytes of each component.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ResourceFormat_compByteWidth_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ResourceFormat_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ResourceFormat___eq__(self, other); break;
    case Py_LT : result = _wrap_ResourceFormat___lt__(self, other); break;
    case Py_NE : result = _wrap_ResourceFormat___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ResourceFormat_methods[] = {
  { "__eq__", (PyCFunction) _wrap_ResourceFormat___eq__, METH_O, (char *) "__eq__(r)" },
  { "__lt__", (PyCFunction) _wrap_ResourceFormat___lt__, METH_O, (char *) "__lt__(r)" },
  { "__ne__", (PyCFunction) _wrap_ResourceFormat___ne__, METH_O, (char *) "__ne__(r)" },
  { "Name", (PyCFunction) _wrap_ResourceFormat_Name, METH_NOARGS, (char *) "\n"
		"Name()\n"
		"\n"
		":return: The name of the format.\n"
		"\n"
		":rtype: str\n"
		"\n"
		"" },
  { "Special", (PyCFunction) _wrap_ResourceFormat_Special, METH_NOARGS, (char *) "\n"
		"Special()\n"
		"\n"
		":return: ``True`` if the ``ResourceFormat`` is a 'special' non-regular type.\n"
		"\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "BGRAOrder", (PyCFunction) _wrap_ResourceFormat_BGRAOrder, METH_NOARGS, (char *) "\n"
		"BGRAOrder()\n"
		"\n"
		":return: ``True`` if the components are to be read in ``BGRA`` order.\n"
		"\n"
		".. note::\n"
		"  The convention is that components are in RGBA order. Whether that means first byte to last byte,\n"
		"  or in bit-packed formats red in the lowest bits.\n"
		"\n"
		"  With BGRA order this means blue is in the first byte/lowest bits, but alpha is still always\n"
		"  expected in the last byte/uppermost bits.\n"
		"\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "SRGBCorrected", (PyCFunction) _wrap_ResourceFormat_SRGBCorrected, METH_NOARGS, (char *) "\n"
		"SRGBCorrected()\n"
		"\n"
		"Equivalent to checking if :data:`compType` is :data:`CompType.UNormSRGB`\n"
		"\n"
		":return: ``True`` if the components are SRGB corrected on read and write.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "YUVSubsampling", (PyCFunction) _wrap_ResourceFormat_YUVSubsampling, METH_NOARGS, (char *) "\n"
		"YUVSubsampling()\n"
		"\n"
		"Get the subsampling rate for a YUV format. Only valid when :data:`type` is\n"
		"a YUV format like :attr:`ResourceFormatType.YUV8`.\n"
		"\n"
		"For other formats, 0 is returned.\n"
		"\n"
		":return: The subsampling rate, e.g. 444 for 4:4:4 or 420 for 4:2:0\n"
		":rtype: int\n"
		"\n"
		"" },
  { "YUVPlaneCount", (PyCFunction) _wrap_ResourceFormat_YUVPlaneCount, METH_NOARGS, (char *) "\n"
		"YUVPlaneCount()\n"
		"\n"
		"Get the number of planes for a YUV format. Only valid when :data:`type` is\n"
		"a YUV format like :attr:`ResourceFormatType.YUV8`.\n"
		"\n"
		"For other formats, 1 is returned.\n"
		"\n"
		":return: The number of planes\n"
		":rtype: int\n"
		"\n"
		"" },
  { "SetBGRAOrder", (PyCFunction) _wrap_ResourceFormat_SetBGRAOrder, METH_O, (char *) "\n"
		"SetBGRAOrder(flag)\n"
		"\n"
		"Set BGRA order flag. See :meth:`BGRAOrder`.\n"
		"\n"
		":param bool flag: The new flag value.\n"
		"\n"
		"" },
  { "SetYUVSubsampling", (PyCFunction) _wrap_ResourceFormat_SetYUVSubsampling, METH_O, (char *) "\n"
		"SetYUVSubsampling(subsampling)\n"
		"\n"
		"Set YUV subsampling rate. See :meth:`YUVSubsampling`.\n"
		"\n"
		"The value should be e.g. 444 for 4:4:4 or 422 for 4:2:2. Invalid values will result in 0 being set.\n"
		"\n"
		":param int subsampling: The new subsampling rate.\n"
		"\n"
		"" },
  { "SetYUVPlaneCount", (PyCFunction) _wrap_ResourceFormat_SetYUVPlaneCount, METH_O, (char *) "\n"
		"SetYUVPlaneCount(planes)\n"
		"\n"
		"Set number of YUV planes. See :meth:`YUVPlaneCount`.\n"
		"\n"
		"Invalid values will result in 1 being set.\n"
		"\n"
		":param int planes: The new number of YUV planes.\n"
		"\n"
		"" },
  { "BlockFormat", (PyCFunction) _wrap_ResourceFormat_BlockFormat, METH_NOARGS, (char *) "\n"
		"BlockFormat()\n"
		"\n"
		":return: ``True`` if the ``ResourceFormat`` is a block-compressed type.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "ElementSize", (PyCFunction) _wrap_ResourceFormat_ElementSize, METH_NOARGS, (char *) "\n"
		"ElementSize()\n"
		"\n"
		"Return the size of a single element in this format, usually a pixel. For regular sized\n"
		"formats this is just :data:`compByteWidth` times :data:`compCount`, for special packed formats it's\n"
		"the tightly packed size of a single element, with no padding.\n"
		"\n"
		"Block-compressed formats define an 'element' as a whole block of texels.\n"
		"\n"
		"YUV formats where texel size varies depending on subsampling will return the size of a decompressed\n"
		"texel.\n"
		"\n"
		":return: The size of an element\n"
		":rtype: int\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ResourceFormat_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ResourceFormat",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ResourceFormat_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ResourceFormat_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__ResourceFormat_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__ResourceFormat_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ResourceFormat_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Description of the format of a resource or element.",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ResourceFormat_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ResourceFormat_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ResourceFormat_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ResourceFormat,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ResourceFormat_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ResourceFormat_type};

static SwigPyGetSet TextureFilter_magnify_getset = { _wrap_TextureFilter_magnify_get, _wrap_TextureFilter_magnify_set };
static SwigPyGetSet TextureFilter_minify_getset = { _wrap_TextureFilter_minify_get, _wrap_TextureFilter_minify_set };
static SwigPyGetSet TextureFilter___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet TextureFilter_filter_getset = { _wrap_TextureFilter_filter_get, _wrap_TextureFilter_filter_set };
static SwigPyGetSet TextureFilter_mip_getset = { _wrap_TextureFilter_mip_get, _wrap_TextureFilter_mip_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TextureFilter_getset[] = {
    { (char *) "magnify", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`FilterMode` to use when magnifying the texture.\n"
		"\n"
		":type: FilterMode\n"
		"\n"
		"", (void *) &TextureFilter_magnify_getset }
,
    { (char *) "minify", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`FilterMode` to use when minifying the texture.\n"
		"\n"
		":type: FilterMode\n"
		"\n"
		"", (void *) &TextureFilter_minify_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TextureFilter.__dict__", (void *) &TextureFilter___dict___getset }
,
    { (char *) "filter", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`FilterFunction` to apply after interpolating values.\n"
		"\n"
		":type: FilterFunction\n"
		"\n"
		"", (void *) &TextureFilter_filter_getset }
,
    { (char *) "mip", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`FilterMode` to use when interpolating between mips.\n"
		"\n"
		":type: FilterMode\n"
		"\n"
		"", (void *) &TextureFilter_mip_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TextureFilter_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_TextureFilter___eq__(self, other); break;
    case Py_LT : result = _wrap_TextureFilter___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TextureFilter_methods[] = {
  { "__eq__", (PyCFunction) _wrap_TextureFilter___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_TextureFilter___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TextureFilter_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.TextureFilter",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TextureFilter_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TextureFilter_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__TextureFilter_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__TextureFilter_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TextureFilter_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The details of a texture filter in a sampler.",              /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TextureFilter_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TextureFilter_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TextureFilter_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TextureFilter,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TextureFilter_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TextureFilter_type};

static SwigPyGetSet TextureSwizzle4_alpha_getset = { _wrap_TextureSwizzle4_alpha_get, _wrap_TextureSwizzle4_alpha_set };
static SwigPyGetSet TextureSwizzle4___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet TextureSwizzle4_blue_getset = { _wrap_TextureSwizzle4_blue_get, _wrap_TextureSwizzle4_blue_set };
static SwigPyGetSet TextureSwizzle4_green_getset = { _wrap_TextureSwizzle4_green_get, _wrap_TextureSwizzle4_green_set };
static SwigPyGetSet TextureSwizzle4_red_getset = { _wrap_TextureSwizzle4_red_get, _wrap_TextureSwizzle4_red_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TextureSwizzle4_getset[] = {
    { (char *) "alpha", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The alpha channel's :class:`TextureSwizzle`.\n"
		"\n"
		":type: TextureSwizzle\n"
		"\n"
		"", (void *) &TextureSwizzle4_alpha_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TextureSwizzle4.__dict__", (void *) &TextureSwizzle4___dict___getset }
,
    { (char *) "blue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The blue channel's :class:`TextureSwizzle`.\n"
		"\n"
		":type: TextureSwizzle\n"
		"\n"
		"", (void *) &TextureSwizzle4_blue_getset }
,
    { (char *) "green", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The green channel's :class:`TextureSwizzle`.\n"
		"\n"
		":type: TextureSwizzle\n"
		"\n"
		"", (void *) &TextureSwizzle4_green_getset }
,
    { (char *) "red", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The red channel's :class:`TextureSwizzle`.\n"
		"\n"
		":type: TextureSwizzle\n"
		"\n"
		"", (void *) &TextureSwizzle4_red_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TextureSwizzle4_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_TextureSwizzle4___eq__(self, other); break;
    case Py_LT : result = _wrap_TextureSwizzle4___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TextureSwizzle4_methods[] = {
  { "__eq__", (PyCFunction) _wrap_TextureSwizzle4___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_TextureSwizzle4___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TextureSwizzle4_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.TextureSwizzle4",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TextureSwizzle4_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TextureSwizzle4_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__TextureSwizzle4_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__TextureSwizzle4_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TextureSwizzle4_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The four components of a texture swizzle.",                  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TextureSwizzle4_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TextureSwizzle4_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TextureSwizzle4_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TextureSwizzle4,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TextureSwizzle4_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TextureSwizzle4_type};

static SwigPyGetSet ResourceDescription_name_getset = { _wrap_ResourceDescription_name_get, _wrap_ResourceDescription_name_set };
static SwigPyGetSet ResourceDescription_resourceId_getset = { _wrap_ResourceDescription_resourceId_get, _wrap_ResourceDescription_resourceId_set };
static SwigPyGetSet ResourceDescription_initialisationChunks_getset = { _wrap_ResourceDescription_initialisationChunks_get, _wrap_ResourceDescription_initialisationChunks_set };
static SwigPyGetSet ResourceDescription___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ResourceDescription_derivedResources_getset = { _wrap_ResourceDescription_derivedResources_get, _wrap_ResourceDescription_derivedResources_set };
static SwigPyGetSet ResourceDescription_parentResources_getset = { _wrap_ResourceDescription_parentResources_get, _wrap_ResourceDescription_parentResources_set };
static SwigPyGetSet ResourceDescription_annotations_getset = { _wrap_ResourceDescription_annotations_get, _wrap_ResourceDescription_annotations_set };
static SwigPyGetSet ResourceDescription_type_getset = { _wrap_ResourceDescription_type_get, _wrap_ResourceDescription_type_set };
static SwigPyGetSet ResourceDescription_autogeneratedName_getset = { _wrap_ResourceDescription_autogeneratedName_get, _wrap_ResourceDescription_autogeneratedName_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ResourceDescription_getset[] = {
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name given to this resource.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ResourceDescription_name_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The unique :class:`ResourceId` that identifies this resource.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &ResourceDescription_resourceId_getset }
,
    { (char *) "initialisationChunks", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The chunk indices in the structured file that initialised this resource.\n"
		"\n"
		"This will at least contain the first call that created it, but may contain other auxilliary calls.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &ResourceDescription_initialisationChunks_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ResourceDescription.__dict__", (void *) &ResourceDescription___dict___getset }
,
    { (char *) "derivedResources", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of any derived resources, such as resource views or aliases.\n"
		"\n"
		"Can be empty if there are no derived resources.\n"
		"\n"
		"This is the inverse of :data:`parentResources` in a potentially many:many relationship, but\n"
		"typically it is one parent to many derived.\n"
		"\n"
		":type: List[ResourceId]\n"
		"\n"
		"", (void *) &ResourceDescription_derivedResources_getset }
,
    { (char *) "parentResources", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of parent resources, of which this is derived.\n"
		"\n"
		"Can be empty if there are no parent resources.\n"
		"\n"
		"This is the inverse of :data:`derivedResources` in a potentially many:many relationship, but\n"
		"typically it is one parent to many derived.\n"
		"\n"
		":type: List[ResourceId]\n"
		"\n"
		"", (void *) &ResourceDescription_parentResources_getset }
,
    { (char *) "annotations", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An optional set of annotations associated with this resource, may be ``None`` if\n"
		"annotations are not used.\n"
		"\n"
		":type: SDObject\n"
		"\n"
		"", (void *) &ResourceDescription_annotations_getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceType` of the resource.\n"
		"\n"
		":type: ResourceType\n"
		"\n"
		"", (void *) &ResourceDescription_type_getset }
,
    { (char *) "autogeneratedName", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if :data:`name` was just autogenerated based on the ID, not assigned a\n"
		"human-readable name by the application.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &ResourceDescription_autogeneratedName_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ResourceDescription_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ResourceDescription___eq__(self, other); break;
    case Py_LT : result = _wrap_ResourceDescription___lt__(self, other); break;
    case Py_NE : result = _wrap_ResourceDescription___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ResourceDescription_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ResourceDescription___lt__, METH_O, (char *) "__lt__(o)" },
  { "SetCustomName", (PyCFunction) _wrap_ResourceDescription_SetCustomName, METH_O, (char *) "\n"
		"SetCustomName(givenName)\n"
		"\n"
		"Utility function for setting up a custom name to overwrite the auto-generated one.\n"
		"\n"
		":param str givenName: The custom name to use.\n"
		"\n"
		"" },
  { "__eq__", (PyCFunction) _wrap_ResourceDescription___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_ResourceDescription___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ResourceDescription_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ResourceDescription",          /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ResourceDescription_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ResourceDescription_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__ResourceDescription_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__ResourceDescription_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ResourceDescription_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A description of any type of resource.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ResourceDescription_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ResourceDescription_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ResourceDescription_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ResourceDescription, /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ResourceDescription_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ResourceDescription_type};

static SwigPyGetSet DescriptorStoreDescription_resourceId_getset = { _wrap_DescriptorStoreDescription_resourceId_get, _wrap_DescriptorStoreDescription_resourceId_set };
static SwigPyGetSet DescriptorStoreDescription_descriptorCount_getset = { _wrap_DescriptorStoreDescription_descriptorCount_get, _wrap_DescriptorStoreDescription_descriptorCount_set };
static SwigPyGetSet DescriptorStoreDescription___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet DescriptorStoreDescription_descriptorByteSize_getset = { _wrap_DescriptorStoreDescription_descriptorByteSize_get, _wrap_DescriptorStoreDescription_descriptorByteSize_set };
static SwigPyGetSet DescriptorStoreDescription_firstDescriptorOffset_getset = { _wrap_DescriptorStoreDescription_firstDescriptorOffset_get, _wrap_DescriptorStoreDescription_firstDescriptorOffset_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DescriptorStoreDescription_getset[] = {
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The unique :class:`ResourceId` that identifies this descriptor store.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &DescriptorStoreDescription_resourceId_getset }
,
    { (char *) "descriptorCount", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of descriptors within this storage object.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DescriptorStoreDescription_descriptorCount_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DescriptorStoreDescription.__dict__", (void *) &DescriptorStoreDescription___dict___getset }
,
    { (char *) "descriptorByteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For descriptor stores which contain desriptors all of identical size, the size of each\n"
		"descriptor. Descriptors are assumed to be tightly packed so stride is equal to size.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DescriptorStoreDescription_descriptorByteSize_getset }
,
    { (char *) "firstDescriptorOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset within the store to the first descriptor.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DescriptorStoreDescription_firstDescriptorOffset_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DescriptorStoreDescription_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_DescriptorStoreDescription___eq__(self, other); break;
    case Py_LT : result = _wrap_DescriptorStoreDescription___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DescriptorStoreDescription_methods[] = {
  { "__eq__", (PyCFunction) _wrap_DescriptorStoreDescription___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_DescriptorStoreDescription___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DescriptorStoreDescription_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.DescriptorStoreDescription",   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DescriptorStoreDescription_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DescriptorStoreDescription_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__DescriptorStoreDescription_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__DescriptorStoreDescription_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DescriptorStoreDescription_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A description of a descriptor store.",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DescriptorStoreDescription_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DescriptorStoreDescription_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DescriptorStoreDescription_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DescriptorStoreDescription,              /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DescriptorStoreDescription_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DescriptorStoreDescription_type};

static SwigPyGetSet BufferDescription_creationFlags_getset = { _wrap_BufferDescription_creationFlags_get, _wrap_BufferDescription_creationFlags_set };
static SwigPyGetSet BufferDescription_length_getset = { _wrap_BufferDescription_length_get, _wrap_BufferDescription_length_set };
static SwigPyGetSet BufferDescription_resourceId_getset = { _wrap_BufferDescription_resourceId_get, _wrap_BufferDescription_resourceId_set };
static SwigPyGetSet BufferDescription___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet BufferDescription_gpuAddress_getset = { _wrap_BufferDescription_gpuAddress_get, _wrap_BufferDescription_gpuAddress_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__BufferDescription_getset[] = {
    { (char *) "creationFlags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The way this buffer will be used in the pipeline.\n"
		"\n"
		":type: BufferCategory\n"
		"\n"
		"", (void *) &BufferDescription_creationFlags_getset }
,
    { (char *) "length", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte length of the buffer.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &BufferDescription_length_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The unique :class:`ResourceId` that identifies this buffer.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &BufferDescription_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"BufferDescription.__dict__", (void *) &BufferDescription___dict___getset }
,
    { (char *) "gpuAddress", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The known base GPU Address of this buffer. 0 if not applicable or available.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &BufferDescription_gpuAddress_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__BufferDescription_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_BufferDescription___eq__(self, other); break;
    case Py_LT : result = _wrap_BufferDescription___lt__(self, other); break;
    case Py_NE : result = _wrap_BufferDescription___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__BufferDescription_methods[] = {
  { "__lt__", (PyCFunction) _wrap_BufferDescription___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_BufferDescription___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_BufferDescription___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__BufferDescription_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.BufferDescription",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_BufferDescription_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__BufferDescription_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__BufferDescription_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__BufferDescription_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__BufferDescription_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A description of a buffer resource.",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__BufferDescription_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__BufferDescription_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__BufferDescription_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_BufferDescription,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__BufferDescription_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__BufferDescription_type};

static SwigPyGetSet TextureDescription_cubemap_getset = { _wrap_TextureDescription_cubemap_get, _wrap_TextureDescription_cubemap_set };
static SwigPyGetSet TextureDescription_mips_getset = { _wrap_TextureDescription_mips_get, _wrap_TextureDescription_mips_set };
static SwigPyGetSet TextureDescription_msSamp_getset = { _wrap_TextureDescription_msSamp_get, _wrap_TextureDescription_msSamp_set };
static SwigPyGetSet TextureDescription_dimension_getset = { _wrap_TextureDescription_dimension_get, _wrap_TextureDescription_dimension_set };
static SwigPyGetSet TextureDescription_height_getset = { _wrap_TextureDescription_height_get, _wrap_TextureDescription_height_set };
static SwigPyGetSet TextureDescription_creationFlags_getset = { _wrap_TextureDescription_creationFlags_get, _wrap_TextureDescription_creationFlags_set };
static SwigPyGetSet TextureDescription_resourceId_getset = { _wrap_TextureDescription_resourceId_get, _wrap_TextureDescription_resourceId_set };
static SwigPyGetSet TextureDescription_format_getset = { _wrap_TextureDescription_format_get, _wrap_TextureDescription_format_set };
static SwigPyGetSet TextureDescription___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet TextureDescription_depth_getset = { _wrap_TextureDescription_depth_get, _wrap_TextureDescription_depth_set };
static SwigPyGetSet TextureDescription_width_getset = { _wrap_TextureDescription_width_get, _wrap_TextureDescription_width_set };
static SwigPyGetSet TextureDescription_type_getset = { _wrap_TextureDescription_type_get, _wrap_TextureDescription_type_set };
static SwigPyGetSet TextureDescription_byteSize_getset = { _wrap_TextureDescription_byteSize_get, _wrap_TextureDescription_byteSize_set };
static SwigPyGetSet TextureDescription_msQual_getset = { _wrap_TextureDescription_msQual_get, _wrap_TextureDescription_msQual_set };
static SwigPyGetSet TextureDescription_arraysize_getset = { _wrap_TextureDescription_arraysize_get, _wrap_TextureDescription_arraysize_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TextureDescription_getset[] = {
    { (char *) "cubemap", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this texture is used as a cubemap or cubemap array.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &TextureDescription_cubemap_getset }
,
    { (char *) "mips", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many mips this texture has, will be at least 1.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureDescription_mips_getset }
,
    { (char *) "msSamp", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many multisampled samples this texture has, will be at least 1.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureDescription_msSamp_getset }
,
    { (char *) "dimension", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The base dimension of the texture - either 1, 2, or 3.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureDescription_dimension_getset }
,
    { (char *) "height", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The height of the texture, or 1 if not applicable.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureDescription_height_getset }
,
    { (char *) "creationFlags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The way this texture will be used in the pipeline.\n"
		"\n"
		":type: TextureCategory\n"
		"\n"
		"", (void *) &TextureDescription_creationFlags_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The unique :class:`ResourceId` that identifies this texture.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &TextureDescription_resourceId_getset }
,
    { (char *) "format", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The format of each pixel in the texture.\n"
		"\n"
		":type: ResourceFormat\n"
		"\n"
		"", (void *) &TextureDescription_format_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TextureDescription.__dict__", (void *) &TextureDescription___dict___getset }
,
    { (char *) "depth", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The depth of the texture, or 1 if not applicable.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureDescription_depth_getset }
,
    { (char *) "width", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The width of the texture, or length for buffer textures.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureDescription_width_getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`TextureType` of the texture.\n"
		"\n"
		":type: TextureType\n"
		"\n"
		"", (void *) &TextureDescription_type_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many bytes would be used to store this texture and all its mips/slices.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureDescription_byteSize_getset }
,
    { (char *) "msQual", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The quality setting of this texture, or 0 if not applicable.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureDescription_msQual_getset }
,
    { (char *) "arraysize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many array elements this texture has, will be at least 1.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &TextureDescription_arraysize_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TextureDescription_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_TextureDescription___eq__(self, other); break;
    case Py_LT : result = _wrap_TextureDescription___lt__(self, other); break;
    case Py_NE : result = _wrap_TextureDescription___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TextureDescription_methods[] = {
  { "__lt__", (PyCFunction) _wrap_TextureDescription___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_TextureDescription___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_TextureDescription___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TextureDescription_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.TextureDescription",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TextureDescription_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TextureDescription_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__TextureDescription_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__TextureDescription_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TextureDescription_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A description of a texture resource.",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TextureDescription_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TextureDescription_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TextureDescription_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TextureDescription,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TextureDescription_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TextureDescription_type};

static SwigPyGetSet APIEvent___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet APIEvent_eventId_getset = { _wrap_APIEvent_eventId_get, _wrap_APIEvent_eventId_set };
static SwigPyGetSet APIEvent_fileOffset_getset = { _wrap_APIEvent_fileOffset_get, _wrap_APIEvent_fileOffset_set };
static SwigPyGetSet APIEvent_annotations_getset = { _wrap_APIEvent_annotations_get, _wrap_APIEvent_annotations_set };
static SwigPyGetSet APIEvent_chunkIndex_getset = { _wrap_APIEvent_chunkIndex_get, _wrap_APIEvent_chunkIndex_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__APIEvent_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"APIEvent.__dict__", (void *) &APIEvent___dict___getset }
,
    { (char *) "eventId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The API event's Event ID.\n"
		"\n"
		"This is a 1-based count of API events in the capture. The eventId is used as a reference point in\n"
		"many places in the API to represent where in the capture the 'current state' is, and to perform\n"
		"analysis in reference to the state at a particular point in the frame.\n"
		"\n"
		"eventIds are generally increasing, positive, and contiguous, with a few exceptions. These are when\n"
		"fake markers are added to a capture with :meth:`ReplayController.AddFakeMarkers`. Thus if strong\n"
		"eventId guarantees are desired, this function should be avoided.\n"
		"\n"
		"Also eventIds may not correspond directly to an actual function call - sometimes a function such as\n"
		"a multi action indirect will be one function call that expands to multiple events to allow inspection\n"
		"of results part way through the multi action.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &APIEvent_eventId_getset }
,
    { (char *) "fileOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A byte offset in the data stream where this event happens.\n"
		"\n"
		".. note:: This should only be used as a relative measure, it is not a literal number of bytes from\n"
		"  the start of the file on disk.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &APIEvent_fileOffset_getset }
,
    { (char *) "annotations", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An optional set of annotations associated with this event, may be ``None`` if\n"
		"annotations are not used.\n"
		"\n"
		":type: SDObject\n"
		"\n"
		"", (void *) &APIEvent_annotations_getset }
,
    { (char *) "chunkIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The chunk index for this function call in the structured file.\n"
		"\n"
		"If no chunk index is available this will be set to :data:`NoChunk`. This will only happen for fake\n"
		"markers added to the capture after load.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &APIEvent_chunkIndex_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__APIEvent_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_APIEvent___eq__(self, other); break;
    case Py_LT : result = _wrap_APIEvent___lt__(self, other); break;
    case Py_NE : result = _wrap_APIEvent___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__APIEvent_methods[] = {
  { "__lt__", (PyCFunction) _wrap_APIEvent___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_APIEvent___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_APIEvent___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__APIEvent_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.APIEvent",                     /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_APIEvent_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__APIEvent_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__APIEvent_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__APIEvent_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__APIEvent_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"An individual API-level event, generally corresponds one-to-one with an API call.\n"
		"\n"
		".. data:: NoChunk\n"
		"\n"
		"  No chunk is available.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__APIEvent_richcompare,            /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__APIEvent_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__APIEvent_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_APIEvent,            /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__APIEvent_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__APIEvent_type};

static SwigPyGetSet DebugMessage_severity_getset = { _wrap_DebugMessage_severity_get, _wrap_DebugMessage_severity_set };
static SwigPyGetSet DebugMessage_messageID_getset = { _wrap_DebugMessage_messageID_get, _wrap_DebugMessage_messageID_set };
static SwigPyGetSet DebugMessage___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet DebugMessage_eventId_getset = { _wrap_DebugMessage_eventId_get, _wrap_DebugMessage_eventId_set };
static SwigPyGetSet DebugMessage_source_getset = { _wrap_DebugMessage_source_get, _wrap_DebugMessage_source_set };
static SwigPyGetSet DebugMessage_category_getset = { _wrap_DebugMessage_category_get, _wrap_DebugMessage_category_set };
static SwigPyGetSet DebugMessage_description_getset = { _wrap_DebugMessage_description_get, _wrap_DebugMessage_description_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DebugMessage_getset[] = {
    { (char *) "severity", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`severity <MessageSeverity>` of this debug message.\n"
		"\n"
		":type: MessageSeverity\n"
		"\n"
		"", (void *) &DebugMessage_severity_getset }
,
    { (char *) "messageID", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An ID that identifies this particular debug message uniquely.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DebugMessage_messageID_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DebugMessage.__dict__", (void *) &DebugMessage___dict___getset }
,
    { (char *) "eventId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :data:`eventId <APIEvent.eventId>` where this debug message was found.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DebugMessage_eventId_getset }
,
    { (char *) "source", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`source <MessageSource>` of this debug message.\n"
		"\n"
		":type: MessageSource\n"
		"\n"
		"", (void *) &DebugMessage_source_getset }
,
    { (char *) "category", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`category <MessageCategory>` of this debug message.\n"
		"\n"
		":type: MessageCategory\n"
		"\n"
		"", (void *) &DebugMessage_category_getset }
,
    { (char *) "description", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The string contents of the message.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &DebugMessage_description_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DebugMessage_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_DebugMessage___eq__(self, other); break;
    case Py_LT : result = _wrap_DebugMessage___lt__(self, other); break;
    case Py_NE : result = _wrap_DebugMessage___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DebugMessage_methods[] = {
  { "__lt__", (PyCFunction) _wrap_DebugMessage___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_DebugMessage___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_DebugMessage___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DebugMessage_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.DebugMessage",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DebugMessage_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DebugMessage_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__DebugMessage_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__DebugMessage_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DebugMessage_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A debugging message from the API validation or internal analysis and error detection.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DebugMessage_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DebugMessage_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DebugMessage_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DebugMessage,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DebugMessage_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DebugMessage_type};

static SwigPyGetSet BucketRecordType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__BucketRecordType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"BucketRecordType.__dict__", (void *) &BucketRecordType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__BucketRecordType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__BucketRecordType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__BucketRecordType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "BucketRecordType",                       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_BucketRecordType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__BucketRecordType_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__BucketRecordType_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__BucketRecordType_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__BucketRecordType_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The type of bucketing method for recording statistics.\n"
		"\n"
		".. data:: Linear\n"
		"\n"
		"  Each bucket contains a fixed number of elements. The highest bucket also accumulates any values\n"
		"  too high for any of the buckets.\n"
		"\n"
		".. data:: Pow2\n"
		"\n"
		"  Each bucket holds twice as many elements as the previous one, with the first bucket containing\n"
		"  just 1 (bucket index is ``log2(value)``).\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__BucketRecordType_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__BucketRecordType_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__BucketRecordType_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_BucketRecordType,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__BucketRecordType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__BucketRecordType_type};

static SwigPyGetSet ConstantBindStats_calls_getset = { _wrap_ConstantBindStats_calls_get, _wrap_ConstantBindStats_calls_set };
static SwigPyGetSet ConstantBindStats___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ConstantBindStats_sizes_getset = { _wrap_ConstantBindStats_sizes_get, _wrap_ConstantBindStats_sizes_set };
static SwigPyGetSet ConstantBindStats_sets_getset = { _wrap_ConstantBindStats_sets_get, _wrap_ConstantBindStats_sets_set };
static SwigPyGetSet ConstantBindStats_bindslots_getset = { _wrap_ConstantBindStats_bindslots_get, _wrap_ConstantBindStats_bindslots_set };
static SwigPyGetSet ConstantBindStats_nulls_getset = { _wrap_ConstantBindStats_nulls_get, _wrap_ConstantBindStats_nulls_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ConstantBindStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many function calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ConstantBindStats_calls_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ConstantBindStats.__dict__", (void *) &ConstantBindStats___dict___getset }
,
    { (char *) "sizes", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A :class:`bucketed <BucketType>` list over the sizes of buffers bound.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &ConstantBindStats_sizes_getset }
,
    { (char *) "sets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ConstantBindStats_sets_getset }
,
    { (char *) "bindslots", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list where the Nth element contains the number of calls that bound N buffers.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &ConstantBindStats_bindslots_getset }
,
    { (char *) "nulls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were unbound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ConstantBindStats_nulls_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ConstantBindStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ConstantBindStats___eq__(self, other); break;
    case Py_LT : result = _wrap_ConstantBindStats___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ConstantBindStats_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ConstantBindStats___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ConstantBindStats___eq__, METH_O, (char *) "__eq__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ConstantBindStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ConstantBindStats",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ConstantBindStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ConstantBindStats_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__ConstantBindStats_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__ConstantBindStats_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ConstantBindStats_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Contains the statistics for constant binds in a frame.\n"
		"\n"
		".. data:: BucketType\n"
		"\n"
		"  The type of buckets being used. See :class:`BucketRecordType`.\n"
		"\n"
		".. data:: BucketCount\n"
		"\n"
		"  How many buckets there are in the arrays.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ConstantBindStats_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ConstantBindStats_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ConstantBindStats_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ConstantBindStats,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ConstantBindStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ConstantBindStats_type};

static SwigPyGetSet SamplerBindStats_calls_getset = { _wrap_SamplerBindStats_calls_get, _wrap_SamplerBindStats_calls_set };
static SwigPyGetSet SamplerBindStats___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet SamplerBindStats_sets_getset = { _wrap_SamplerBindStats_sets_get, _wrap_SamplerBindStats_sets_set };
static SwigPyGetSet SamplerBindStats_bindslots_getset = { _wrap_SamplerBindStats_bindslots_get, _wrap_SamplerBindStats_bindslots_set };
static SwigPyGetSet SamplerBindStats_nulls_getset = { _wrap_SamplerBindStats_nulls_get, _wrap_SamplerBindStats_nulls_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SamplerBindStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many function calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SamplerBindStats_calls_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SamplerBindStats.__dict__", (void *) &SamplerBindStats___dict___getset }
,
    { (char *) "sets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SamplerBindStats_sets_getset }
,
    { (char *) "bindslots", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list where the Nth element contains the number of calls that bound N samplers.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &SamplerBindStats_bindslots_getset }
,
    { (char *) "nulls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were unbound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SamplerBindStats_nulls_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SamplerBindStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_SamplerBindStats___eq__(self, other); break;
    case Py_LT : result = _wrap_SamplerBindStats___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SamplerBindStats_methods[] = {
  { "__lt__", (PyCFunction) _wrap_SamplerBindStats___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_SamplerBindStats___eq__, METH_O, (char *) "__eq__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SamplerBindStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.SamplerBindStats",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_SamplerBindStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SamplerBindStats_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__SamplerBindStats_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__SamplerBindStats_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SamplerBindStats_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the statistics for sampler binds in a frame.",      /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SamplerBindStats_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SamplerBindStats_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SamplerBindStats_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_SamplerBindStats,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SamplerBindStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SamplerBindStats_type};

static SwigPyGetSet ResourceBindStats_calls_getset = { _wrap_ResourceBindStats_calls_get, _wrap_ResourceBindStats_calls_set };
static SwigPyGetSet ResourceBindStats___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ResourceBindStats_types_getset = { _wrap_ResourceBindStats_types_get, _wrap_ResourceBindStats_types_set };
static SwigPyGetSet ResourceBindStats_sets_getset = { _wrap_ResourceBindStats_sets_get, _wrap_ResourceBindStats_sets_set };
static SwigPyGetSet ResourceBindStats_bindslots_getset = { _wrap_ResourceBindStats_bindslots_get, _wrap_ResourceBindStats_bindslots_set };
static SwigPyGetSet ResourceBindStats_nulls_getset = { _wrap_ResourceBindStats_nulls_get, _wrap_ResourceBindStats_nulls_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ResourceBindStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many function calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ResourceBindStats_calls_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ResourceBindStats.__dict__", (void *) &ResourceBindStats___dict___getset }
,
    { (char *) "types", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list with one element for each type in :class:`TextureType`.\n"
		"\n"
		"The Nth element contains the number of times a resource of that type was bound.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &ResourceBindStats_types_getset }
,
    { (char *) "sets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ResourceBindStats_sets_getset }
,
    { (char *) "bindslots", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list where the Nth element contains the number of calls that bound N resources.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &ResourceBindStats_bindslots_getset }
,
    { (char *) "nulls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were unbound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ResourceBindStats_nulls_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ResourceBindStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ResourceBindStats___eq__(self, other); break;
    case Py_LT : result = _wrap_ResourceBindStats___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ResourceBindStats_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ResourceBindStats___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ResourceBindStats___eq__, METH_O, (char *) "__eq__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ResourceBindStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ResourceBindStats",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ResourceBindStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ResourceBindStats_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__ResourceBindStats_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__ResourceBindStats_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ResourceBindStats_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the statistics for resource binds in a frame.",     /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ResourceBindStats_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ResourceBindStats_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ResourceBindStats_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ResourceBindStats,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ResourceBindStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ResourceBindStats_type};

static SwigPyGetSet ResourceUpdateStats_calls_getset = { _wrap_ResourceUpdateStats_calls_get, _wrap_ResourceUpdateStats_calls_set };
static SwigPyGetSet ResourceUpdateStats___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ResourceUpdateStats_sizes_getset = { _wrap_ResourceUpdateStats_sizes_get, _wrap_ResourceUpdateStats_sizes_set };
static SwigPyGetSet ResourceUpdateStats_servers_getset = { _wrap_ResourceUpdateStats_servers_get, _wrap_ResourceUpdateStats_servers_set };
static SwigPyGetSet ResourceUpdateStats_types_getset = { _wrap_ResourceUpdateStats_types_get, _wrap_ResourceUpdateStats_types_set };
static SwigPyGetSet ResourceUpdateStats_clients_getset = { _wrap_ResourceUpdateStats_clients_get, _wrap_ResourceUpdateStats_clients_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ResourceUpdateStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many function calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ResourceUpdateStats_calls_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ResourceUpdateStats.__dict__", (void *) &ResourceUpdateStats___dict___getset }
,
    { (char *) "sizes", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A :class:`bucketed <BucketType>` list over the number of bytes in the update.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &ResourceUpdateStats_sizes_getset }
,
    { (char *) "servers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many of :data:`calls` were batched updates written in the command queue.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ResourceUpdateStats_servers_getset }
,
    { (char *) "types", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list with one element for each type in :class:`TextureType`.\n"
		"\n"
		"The Nth element contains the number of times a resource of that type was updated.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &ResourceUpdateStats_types_getset }
,
    { (char *) "clients", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many of :data:`calls` were mapped pointers written by the CPU.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ResourceUpdateStats_clients_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ResourceUpdateStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ResourceUpdateStats_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ResourceUpdateStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ResourceUpdateStats",          /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ResourceUpdateStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ResourceUpdateStats_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__ResourceUpdateStats_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__ResourceUpdateStats_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ResourceUpdateStats_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Contains the statistics for resource updates in a frame.\n"
		"\n"
		".. data:: BucketType\n"
		"\n"
		"  The type of buckets being used. See :class:`BucketRecordType`.\n"
		"\n"
		".. data:: BucketCount\n"
		"\n"
		"  How many buckets there are in the arrays.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ResourceUpdateStats_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ResourceUpdateStats_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ResourceUpdateStats_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ResourceUpdateStats, /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ResourceUpdateStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ResourceUpdateStats_type};

static SwigPyGetSet DrawcallStats_calls_getset = { _wrap_DrawcallStats_calls_get, _wrap_DrawcallStats_calls_set };
static SwigPyGetSet DrawcallStats_instanced_getset = { _wrap_DrawcallStats_instanced_get, _wrap_DrawcallStats_instanced_set };
static SwigPyGetSet DrawcallStats_indirect_getset = { _wrap_DrawcallStats_indirect_get, _wrap_DrawcallStats_indirect_set };
static SwigPyGetSet DrawcallStats___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet DrawcallStats_counts_getset = { _wrap_DrawcallStats_counts_get, _wrap_DrawcallStats_counts_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DrawcallStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many draw calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DrawcallStats_calls_getset }
,
    { (char *) "instanced", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many of :data:`calls` were instanced.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DrawcallStats_instanced_getset }
,
    { (char *) "indirect", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many of :data:`calls` were indirect.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DrawcallStats_indirect_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DrawcallStats.__dict__", (void *) &DrawcallStats___dict___getset }
,
    { (char *) "counts", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A :class:`bucketed <BucketType>` list over the number of instances in the draw.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &DrawcallStats_counts_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DrawcallStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DrawcallStats_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DrawcallStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.DrawcallStats",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DrawcallStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DrawcallStats_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__DrawcallStats_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__DrawcallStats_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DrawcallStats_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Contains the statistics for draws in a frame.\n"
		"\n"
		".. data:: BucketType\n"
		"\n"
		"  The type of buckets being used. See :class:`BucketRecordType`.\n"
		"\n"
		".. data:: BucketSize\n"
		"\n"
		"  How many elements each bucket contains.\n"
		"\n"
		".. data:: BucketCount\n"
		"\n"
		"  How many buckets there are in the arrays.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DrawcallStats_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DrawcallStats_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DrawcallStats_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DrawcallStats,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DrawcallStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DrawcallStats_type};

static SwigPyGetSet DispatchStats_calls_getset = { _wrap_DispatchStats_calls_get, _wrap_DispatchStats_calls_set };
static SwigPyGetSet DispatchStats_indirect_getset = { _wrap_DispatchStats_indirect_get, _wrap_DispatchStats_indirect_set };
static SwigPyGetSet DispatchStats___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DispatchStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many dispatch calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DispatchStats_calls_getset }
,
    { (char *) "indirect", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many of :data:`calls` were indirect.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DispatchStats_indirect_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DispatchStats.__dict__", (void *) &DispatchStats___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DispatchStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DispatchStats_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DispatchStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.DispatchStats",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DispatchStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DispatchStats_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__DispatchStats_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__DispatchStats_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DispatchStats_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the statistics for compute dispatches in a frame.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DispatchStats_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DispatchStats_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DispatchStats_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DispatchStats,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DispatchStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DispatchStats_type};

static SwigPyGetSet IndexBindStats_calls_getset = { _wrap_IndexBindStats_calls_get, _wrap_IndexBindStats_calls_set };
static SwigPyGetSet IndexBindStats___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet IndexBindStats_sets_getset = { _wrap_IndexBindStats_sets_get, _wrap_IndexBindStats_sets_set };
static SwigPyGetSet IndexBindStats_nulls_getset = { _wrap_IndexBindStats_nulls_get, _wrap_IndexBindStats_nulls_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__IndexBindStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many function calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &IndexBindStats_calls_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"IndexBindStats.__dict__", (void *) &IndexBindStats___dict___getset }
,
    { (char *) "sets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &IndexBindStats_sets_getset }
,
    { (char *) "nulls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were unbound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &IndexBindStats_nulls_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__IndexBindStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__IndexBindStats_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__IndexBindStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.IndexBindStats",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_IndexBindStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__IndexBindStats_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__IndexBindStats_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__IndexBindStats_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__IndexBindStats_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the statistics for index buffer binds in a frame.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__IndexBindStats_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__IndexBindStats_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__IndexBindStats_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_IndexBindStats,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__IndexBindStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__IndexBindStats_type};

static SwigPyGetSet VertexBindStats_calls_getset = { _wrap_VertexBindStats_calls_get, _wrap_VertexBindStats_calls_set };
static SwigPyGetSet VertexBindStats___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VertexBindStats_sets_getset = { _wrap_VertexBindStats_sets_get, _wrap_VertexBindStats_sets_set };
static SwigPyGetSet VertexBindStats_bindslots_getset = { _wrap_VertexBindStats_bindslots_get, _wrap_VertexBindStats_bindslots_set };
static SwigPyGetSet VertexBindStats_nulls_getset = { _wrap_VertexBindStats_nulls_get, _wrap_VertexBindStats_nulls_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VertexBindStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many function calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VertexBindStats_calls_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VertexBindStats.__dict__", (void *) &VertexBindStats___dict___getset }
,
    { (char *) "sets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VertexBindStats_sets_getset }
,
    { (char *) "bindslots", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list where the Nth element contains the number of calls that bound N vertex buffers.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &VertexBindStats_bindslots_getset }
,
    { (char *) "nulls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were unbound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VertexBindStats_nulls_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VertexBindStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VertexBindStats_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VertexBindStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VertexBindStats",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VertexBindStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VertexBindStats_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__VertexBindStats_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__VertexBindStats_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VertexBindStats_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the statistics for vertex buffer binds in a frame.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VertexBindStats_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VertexBindStats_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VertexBindStats_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VertexBindStats,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VertexBindStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VertexBindStats_type};

static SwigPyGetSet LayoutBindStats_calls_getset = { _wrap_LayoutBindStats_calls_get, _wrap_LayoutBindStats_calls_set };
static SwigPyGetSet LayoutBindStats___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet LayoutBindStats_sets_getset = { _wrap_LayoutBindStats_sets_get, _wrap_LayoutBindStats_sets_set };
static SwigPyGetSet LayoutBindStats_nulls_getset = { _wrap_LayoutBindStats_nulls_get, _wrap_LayoutBindStats_nulls_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__LayoutBindStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many function calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &LayoutBindStats_calls_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"LayoutBindStats.__dict__", (void *) &LayoutBindStats___dict___getset }
,
    { (char *) "sets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &LayoutBindStats_sets_getset }
,
    { (char *) "nulls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were unbound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &LayoutBindStats_nulls_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__LayoutBindStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__LayoutBindStats_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__LayoutBindStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.LayoutBindStats",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_LayoutBindStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__LayoutBindStats_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__LayoutBindStats_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__LayoutBindStats_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__LayoutBindStats_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the statistics for vertex layout binds in a frame.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__LayoutBindStats_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__LayoutBindStats_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__LayoutBindStats_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_LayoutBindStats,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__LayoutBindStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__LayoutBindStats_type};

static SwigPyGetSet ShaderChangeStats_calls_getset = { _wrap_ShaderChangeStats_calls_get, _wrap_ShaderChangeStats_calls_set };
static SwigPyGetSet ShaderChangeStats_redundants_getset = { _wrap_ShaderChangeStats_redundants_get, _wrap_ShaderChangeStats_redundants_set };
static SwigPyGetSet ShaderChangeStats___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderChangeStats_sets_getset = { _wrap_ShaderChangeStats_sets_get, _wrap_ShaderChangeStats_sets_set };
static SwigPyGetSet ShaderChangeStats_nulls_getset = { _wrap_ShaderChangeStats_nulls_get, _wrap_ShaderChangeStats_nulls_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderChangeStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many function calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderChangeStats_calls_getset }
,
    { (char *) "redundants", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many calls made no change due to the existing bind being identical.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderChangeStats_redundants_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderChangeStats.__dict__", (void *) &ShaderChangeStats___dict___getset }
,
    { (char *) "sets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderChangeStats_sets_getset }
,
    { (char *) "nulls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were unbound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderChangeStats_nulls_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderChangeStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderChangeStats___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderChangeStats___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderChangeStats_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ShaderChangeStats___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ShaderChangeStats___eq__, METH_O, (char *) "__eq__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderChangeStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderChangeStats",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderChangeStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderChangeStats_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__ShaderChangeStats_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__ShaderChangeStats_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderChangeStats_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the statistics for shader binds in a frame.",       /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderChangeStats_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderChangeStats_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderChangeStats_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderChangeStats,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderChangeStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderChangeStats_type};

static SwigPyGetSet BlendStats_calls_getset = { _wrap_BlendStats_calls_get, _wrap_BlendStats_calls_set };
static SwigPyGetSet BlendStats_redundants_getset = { _wrap_BlendStats_redundants_get, _wrap_BlendStats_redundants_set };
static SwigPyGetSet BlendStats___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet BlendStats_sets_getset = { _wrap_BlendStats_sets_get, _wrap_BlendStats_sets_set };
static SwigPyGetSet BlendStats_nulls_getset = { _wrap_BlendStats_nulls_get, _wrap_BlendStats_nulls_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__BlendStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many function calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &BlendStats_calls_getset }
,
    { (char *) "redundants", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many calls made no change due to the existing bind being identical.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &BlendStats_redundants_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"BlendStats.__dict__", (void *) &BlendStats___dict___getset }
,
    { (char *) "sets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &BlendStats_sets_getset }
,
    { (char *) "nulls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were unbound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &BlendStats_nulls_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__BlendStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__BlendStats_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__BlendStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.BlendStats",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_BlendStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__BlendStats_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__BlendStats_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__BlendStats_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__BlendStats_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the statistics for blend state binds in a frame.",  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__BlendStats_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__BlendStats_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__BlendStats_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_BlendStats,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__BlendStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__BlendStats_type};

static SwigPyGetSet DepthStencilStats_calls_getset = { _wrap_DepthStencilStats_calls_get, _wrap_DepthStencilStats_calls_set };
static SwigPyGetSet DepthStencilStats_redundants_getset = { _wrap_DepthStencilStats_redundants_get, _wrap_DepthStencilStats_redundants_set };
static SwigPyGetSet DepthStencilStats___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet DepthStencilStats_sets_getset = { _wrap_DepthStencilStats_sets_get, _wrap_DepthStencilStats_sets_set };
static SwigPyGetSet DepthStencilStats_nulls_getset = { _wrap_DepthStencilStats_nulls_get, _wrap_DepthStencilStats_nulls_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DepthStencilStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many function calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DepthStencilStats_calls_getset }
,
    { (char *) "redundants", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many calls made no change due to the existing bind being identical.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DepthStencilStats_redundants_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DepthStencilStats.__dict__", (void *) &DepthStencilStats___dict___getset }
,
    { (char *) "sets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DepthStencilStats_sets_getset }
,
    { (char *) "nulls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were unbound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DepthStencilStats_nulls_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DepthStencilStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DepthStencilStats_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DepthStencilStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.DepthStencilStats",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DepthStencilStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DepthStencilStats_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__DepthStencilStats_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__DepthStencilStats_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DepthStencilStats_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the statistics for depth stencil state binds in a frame.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DepthStencilStats_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DepthStencilStats_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DepthStencilStats_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DepthStencilStats,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DepthStencilStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DepthStencilStats_type};

static SwigPyGetSet RasterizationStats_calls_getset = { _wrap_RasterizationStats_calls_get, _wrap_RasterizationStats_calls_set };
static SwigPyGetSet RasterizationStats_redundants_getset = { _wrap_RasterizationStats_redundants_get, _wrap_RasterizationStats_redundants_set };
static SwigPyGetSet RasterizationStats_rects_getset = { _wrap_RasterizationStats_rects_get, _wrap_RasterizationStats_rects_set };
static SwigPyGetSet RasterizationStats___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet RasterizationStats_sets_getset = { _wrap_RasterizationStats_sets_get, _wrap_RasterizationStats_sets_set };
static SwigPyGetSet RasterizationStats_viewports_getset = { _wrap_RasterizationStats_viewports_get, _wrap_RasterizationStats_viewports_set };
static SwigPyGetSet RasterizationStats_nulls_getset = { _wrap_RasterizationStats_nulls_get, _wrap_RasterizationStats_nulls_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__RasterizationStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many function calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &RasterizationStats_calls_getset }
,
    { (char *) "redundants", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many calls made no change due to the existing bind being identical.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &RasterizationStats_redundants_getset }
,
    { (char *) "rects", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list where the Nth element contains the number of calls that bound N scissor rects.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &RasterizationStats_rects_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"RasterizationStats.__dict__", (void *) &RasterizationStats___dict___getset }
,
    { (char *) "sets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &RasterizationStats_sets_getset }
,
    { (char *) "viewports", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list where the Nth element contains the number of calls that bound N viewports.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &RasterizationStats_viewports_getset }
,
    { (char *) "nulls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were unbound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &RasterizationStats_nulls_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__RasterizationStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__RasterizationStats_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__RasterizationStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.RasterizationStats",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_RasterizationStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__RasterizationStats_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__RasterizationStats_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__RasterizationStats_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__RasterizationStats_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the statistics for rasterizer state binds in a frame.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__RasterizationStats_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__RasterizationStats_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__RasterizationStats_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_RasterizationStats,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__RasterizationStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__RasterizationStats_type};

static SwigPyGetSet OutputTargetStats_calls_getset = { _wrap_OutputTargetStats_calls_get, _wrap_OutputTargetStats_calls_set };
static SwigPyGetSet OutputTargetStats___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet OutputTargetStats_sets_getset = { _wrap_OutputTargetStats_sets_get, _wrap_OutputTargetStats_sets_set };
static SwigPyGetSet OutputTargetStats_bindslots_getset = { _wrap_OutputTargetStats_bindslots_get, _wrap_OutputTargetStats_bindslots_set };
static SwigPyGetSet OutputTargetStats_nulls_getset = { _wrap_OutputTargetStats_nulls_get, _wrap_OutputTargetStats_nulls_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__OutputTargetStats_getset[] = {
    { (char *) "calls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many function calls were made.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &OutputTargetStats_calls_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"OutputTargetStats.__dict__", (void *) &OutputTargetStats___dict___getset }
,
    { (char *) "sets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &OutputTargetStats_sets_getset }
,
    { (char *) "bindslots", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list where the Nth element contains the number of calls that bound N targets.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &OutputTargetStats_bindslots_getset }
,
    { (char *) "nulls", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many objects were unbound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &OutputTargetStats_nulls_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__OutputTargetStats_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__OutputTargetStats_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__OutputTargetStats_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.OutputTargetStats",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_OutputTargetStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__OutputTargetStats_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__OutputTargetStats_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__OutputTargetStats_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__OutputTargetStats_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the statistics for output merger or UAV binds in a frame.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__OutputTargetStats_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__OutputTargetStats_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__OutputTargetStats_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_OutputTargetStats,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__OutputTargetStats_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__OutputTargetStats_type};

static SwigPyGetSet FrameStatistics_blends_getset = { _wrap_FrameStatistics_blends_get, _wrap_FrameStatistics_blends_set };
static SwigPyGetSet FrameStatistics_draws_getset = { _wrap_FrameStatistics_draws_get, _wrap_FrameStatistics_draws_set };
static SwigPyGetSet FrameStatistics_vertices_getset = { _wrap_FrameStatistics_vertices_get, _wrap_FrameStatistics_vertices_set };
static SwigPyGetSet FrameStatistics_layouts_getset = { _wrap_FrameStatistics_layouts_get, _wrap_FrameStatistics_layouts_set };
static SwigPyGetSet FrameStatistics_samplers_getset = { _wrap_FrameStatistics_samplers_get, _wrap_FrameStatistics_samplers_set };
static SwigPyGetSet FrameStatistics_shaders_getset = { _wrap_FrameStatistics_shaders_get, _wrap_FrameStatistics_shaders_set };
static SwigPyGetSet FrameStatistics___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet FrameStatistics_resources_getset = { _wrap_FrameStatistics_resources_get, _wrap_FrameStatistics_resources_set };
static SwigPyGetSet FrameStatistics_depths_getset = { _wrap_FrameStatistics_depths_get, _wrap_FrameStatistics_depths_set };
static SwigPyGetSet FrameStatistics_constants_getset = { _wrap_FrameStatistics_constants_get, _wrap_FrameStatistics_constants_set };
static SwigPyGetSet FrameStatistics_updates_getset = { _wrap_FrameStatistics_updates_get, _wrap_FrameStatistics_updates_set };
static SwigPyGetSet FrameStatistics_indices_getset = { _wrap_FrameStatistics_indices_get, _wrap_FrameStatistics_indices_set };
static SwigPyGetSet FrameStatistics_outputs_getset = { _wrap_FrameStatistics_outputs_get, _wrap_FrameStatistics_outputs_set };
static SwigPyGetSet FrameStatistics_rasters_getset = { _wrap_FrameStatistics_rasters_get, _wrap_FrameStatistics_rasters_set };
static SwigPyGetSet FrameStatistics_recorded_getset = { _wrap_FrameStatistics_recorded_get, _wrap_FrameStatistics_recorded_set };
static SwigPyGetSet FrameStatistics_dispatches_getset = { _wrap_FrameStatistics_dispatches_get, _wrap_FrameStatistics_dispatches_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__FrameStatistics_getset[] = {
    { (char *) "blends", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Information about blend state binds.\n"
		"\n"
		":type: BlendStats\n"
		"\n"
		"", (void *) &FrameStatistics_blends_getset }
,
    { (char *) "draws", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Information about drawcalls.\n"
		"\n"
		":type: DrawcallStats\n"
		"\n"
		"", (void *) &FrameStatistics_draws_getset }
,
    { (char *) "vertices", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Information about vertex buffer binds.\n"
		"\n"
		":type: VertexBindStats\n"
		"\n"
		"", (void *) &FrameStatistics_vertices_getset }
,
    { (char *) "layouts", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Information about vertex layout binds.\n"
		"\n"
		":type: LayoutBindStats\n"
		"\n"
		"", (void *) &FrameStatistics_layouts_getset }
,
    { (char *) "samplers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list of sampler bind statistics, one per each :class:`stage <ShaderStage>`.\n"
		"\n"
		":type: List[SamplerBindStats]\n"
		"\n"
		"", (void *) &FrameStatistics_samplers_getset }
,
    { (char *) "shaders", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list of shader bind statistics, one per each :class:`stage <ShaderStage>`.\n"
		"\n"
		":type: List[ShaderChangeStats]\n"
		"\n"
		"", (void *) &FrameStatistics_shaders_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"FrameStatistics.__dict__", (void *) &FrameStatistics___dict___getset }
,
    { (char *) "resources", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list of resource bind statistics, one per each :class:`stage <ShaderStage>`.\n"
		"\n"
		":type: List[ResourceBindStats]\n"
		"\n"
		"", (void *) &FrameStatistics_resources_getset }
,
    { (char *) "depths", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Information about depth-stencil state binds.\n"
		"\n"
		":type: DepthStencilStats\n"
		"\n"
		"", (void *) &FrameStatistics_depths_getset }
,
    { (char *) "constants", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list of constant buffer bind statistics, one per each :class:`stage <ShaderStage>`.\n"
		"\n"
		":type: List[ConstantBindStats]\n"
		"\n"
		"", (void *) &FrameStatistics_constants_getset }
,
    { (char *) "updates", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Information about resource contents updates.\n"
		"\n"
		":type: ResourceUpdateStats\n"
		"\n"
		"", (void *) &FrameStatistics_updates_getset }
,
    { (char *) "indices", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Information about index buffer binds.\n"
		"\n"
		":type: IndexBindStats\n"
		"\n"
		"", (void *) &FrameStatistics_indices_getset }
,
    { (char *) "outputs", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Information about output merger and UAV binds.\n"
		"\n"
		":type: OutputTargetStats\n"
		"\n"
		"", (void *) &FrameStatistics_outputs_getset }
,
    { (char *) "rasters", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Information about rasterizer state binds.\n"
		"\n"
		":type: RasterizationStats\n"
		"\n"
		"", (void *) &FrameStatistics_rasters_getset }
,
    { (char *) "recorded", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the statistics in this structure are valid.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &FrameStatistics_recorded_getset }
,
    { (char *) "dispatches", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Information about compute dispatches.\n"
		"\n"
		":type: DispatchStats\n"
		"\n"
		"", (void *) &FrameStatistics_dispatches_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__FrameStatistics_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__FrameStatistics_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__FrameStatistics_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.FrameStatistics",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_FrameStatistics_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__FrameStatistics_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__FrameStatistics_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__FrameStatistics_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__FrameStatistics_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Contains all the available statistics about the captured frame.\n"
		"\n"
		"Currently this information is only available on D3D11 and is fairly API-centric.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__FrameStatistics_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__FrameStatistics_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__FrameStatistics_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_FrameStatistics,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__FrameStatistics_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__FrameStatistics_type};

static SwigPyGetSet FrameDescription_persistentSize_getset = { _wrap_FrameDescription_persistentSize_get, _wrap_FrameDescription_persistentSize_set };
static SwigPyGetSet FrameDescription_frameNumber_getset = { _wrap_FrameDescription_frameNumber_get, _wrap_FrameDescription_frameNumber_set };
static SwigPyGetSet FrameDescription___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet FrameDescription_captureTime_getset = { _wrap_FrameDescription_captureTime_get, _wrap_FrameDescription_captureTime_set };
static SwigPyGetSet FrameDescription_fileOffset_getset = { _wrap_FrameDescription_fileOffset_get, _wrap_FrameDescription_fileOffset_set };
static SwigPyGetSet FrameDescription_stats_getset = { _wrap_FrameDescription_stats_get, _wrap_FrameDescription_stats_set };
static SwigPyGetSet FrameDescription_containsAnnotations_getset = { _wrap_FrameDescription_containsAnnotations_get, _wrap_FrameDescription_containsAnnotations_set };
static SwigPyGetSet FrameDescription_uncompressedFileSize_getset = { _wrap_FrameDescription_uncompressedFileSize_get, _wrap_FrameDescription_uncompressedFileSize_set };
static SwigPyGetSet FrameDescription_compressedFileSize_getset = { _wrap_FrameDescription_compressedFileSize_get, _wrap_FrameDescription_compressedFileSize_set };
static SwigPyGetSet FrameDescription_initDataSize_getset = { _wrap_FrameDescription_initDataSize_get, _wrap_FrameDescription_initDataSize_set };
static SwigPyGetSet FrameDescription_debugMessages_getset = { _wrap_FrameDescription_debugMessages_get, _wrap_FrameDescription_debugMessages_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__FrameDescription_getset[] = {
    { (char *) "persistentSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte size of the section of the file that must be kept in memory persistently.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &FrameDescription_persistentSize_getset }
,
    { (char *) "frameNumber", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Starting from frame #1 defined as the time from application startup to first present,\n"
		"this counts the frame number when the capture was made.\n"
		"\n"
		".. note:: This value is only accurate if the capture was triggered through the default mechanism, if\n"
		"  it was triggered from the application API it doesn't correspond to anything and will be set to\n"
		"  :data:`NoFrameNumber`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &FrameDescription_frameNumber_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"FrameDescription.__dict__", (void *) &FrameDescription___dict___getset }
,
    { (char *) "captureTime", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The time when the capture was created, as a unix timestamp in UTC.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &FrameDescription_captureTime_getset }
,
    { (char *) "fileOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset into the file of the start of the frame.\n"
		"\n"
		".. note:: Similarly to :data:`APIEvent.fileOffset` this should only be used as a relative measure,\n"
		"  as it is not a literal number of bytes from the start of the file on disk.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &FrameDescription_fileOffset_getset }
,
    { (char *) "stats", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The frame statistics.\n"
		"\n"
		":type: FrameStatistics\n"
		"\n"
		"", (void *) &FrameDescription_stats_getset }
,
    { (char *) "containsAnnotations", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Whether or not the capture contains any annotations.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &FrameDescription_containsAnnotations_getset }
,
    { (char *) "uncompressedFileSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The total file size of the whole capture in bytes, after decompression.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &FrameDescription_uncompressedFileSize_getset }
,
    { (char *) "compressedFileSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The total file size of the whole capture in bytes, before decompression.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &FrameDescription_compressedFileSize_getset }
,
    { (char *) "initDataSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte size of the section of the file that contains frame-initial contents.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &FrameDescription_initDataSize_getset }
,
    { (char *) "debugMessages", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The debug messages that are not associated with any particular event.\n"
		"\n"
		":type: List[DebugMessage]\n"
		"\n"
		"", (void *) &FrameDescription_debugMessages_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__FrameDescription_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__FrameDescription_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__FrameDescription_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.FrameDescription",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_FrameDescription_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__FrameDescription_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__FrameDescription_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__FrameDescription_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__FrameDescription_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Contains frame-level global information\n"
		"\n"
		".. data:: NoFrameNumber\n"
		"\n"
		"  No frame number is available.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__FrameDescription_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__FrameDescription_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__FrameDescription_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_FrameDescription,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__FrameDescription_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__FrameDescription_type};

static SwigPyGetSet EventUsage___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet EventUsage_eventId_getset = { _wrap_EventUsage_eventId_get, _wrap_EventUsage_eventId_set };
static SwigPyGetSet EventUsage_usage_getset = { _wrap_EventUsage_usage_get, _wrap_EventUsage_usage_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__EventUsage_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"EventUsage.__dict__", (void *) &EventUsage___dict___getset }
,
    { (char *) "eventId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :data:`eventId <APIEvent.eventId>` where this usage happened.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &EventUsage_eventId_getset }
,
    { (char *) "usage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceUsage` in question.\n"
		"\n"
		":type: ResourceUsage\n"
		"\n"
		"", (void *) &EventUsage_usage_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__EventUsage_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_EventUsage___eq__(self, other); break;
    case Py_LT : result = _wrap_EventUsage___lt__(self, other); break;
    case Py_NE : result = _wrap_EventUsage___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__EventUsage_methods[] = {
  { "__lt__", (PyCFunction) _wrap_EventUsage___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_EventUsage___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_EventUsage___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__EventUsage_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.EventUsage",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_EventUsage_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__EventUsage_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__EventUsage_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__EventUsage_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__EventUsage_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a particular use of a resource at a specific :data:`eventId <APIEvent.eventId>`.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__EventUsage_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__EventUsage_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__EventUsage_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_EventUsage,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__EventUsage_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__EventUsage_type};

static SwigPyGetSet Subresource___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet Subresource_slice_getset = { _wrap_Subresource_slice_get, _wrap_Subresource_slice_set };
static SwigPyGetSet Subresource_sample_getset = { _wrap_Subresource_sample_get, _wrap_Subresource_sample_set };
static SwigPyGetSet Subresource_mip_getset = { _wrap_Subresource_mip_get, _wrap_Subresource_mip_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__Subresource_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"Subresource.__dict__", (void *) &Subresource___dict___getset }
,
    { (char *) "slice", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The slice within the texture. For array textures this is an array slice. For 3D textures\n"
		"when a single depth slice can be referred to this refers to that depth slice. In some cases a 3D\n"
		"texture may not allow referring to a single depth slice - see where the Subresource is used.\n"
		"\n"
		".. note::\n"
		"  Cubemaps are simply 2D array textures with a special meaning, so the faces of a cubemap are the 2D\n"
		"  array slices in the standard order: X+, X-, Y+, Y-, Z+, Z-. Cubemap arrays are 2D arrays with\n"
		"  ``6 * N`` faces, where each cubemap within the array takes up 6 slices in the above order.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Subresource_slice_getset }
,
    { (char *) "sample", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The sample in a multisampled texture.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Subresource_sample_getset }
,
    { (char *) "mip", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The mip level in the texture.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Subresource_mip_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__Subresource_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_Subresource___eq__(self, other); break;
    case Py_NE : result = _wrap_Subresource___ne__(self, other); break;
    case Py_LT : result = _wrap_Subresource___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__Subresource_methods[] = {
  { "__eq__", (PyCFunction) _wrap_Subresource___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_Subresource___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_Subresource___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__Subresource_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.Subresource",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_Subresource_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__Subresource_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__Subresource_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__Subresource_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__Subresource_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Specifies a subresource within a texture.",                  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__Subresource_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__Subresource_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__Subresource_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_Subresource,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__Subresource_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__Subresource_type};

static SwigPyGetSet ActionDescription_markerColor_getset = { _wrap_ActionDescription_markerColor_get, _wrap_ActionDescription_markerColor_set };
static SwigPyGetSet ActionDescription_numInstances_getset = { _wrap_ActionDescription_numInstances_get, _wrap_ActionDescription_numInstances_set };
static SwigPyGetSet ActionDescription_actionId_getset = { _wrap_ActionDescription_actionId_get, _wrap_ActionDescription_actionId_set };
static SwigPyGetSet ActionDescription_dispatchDimension_getset = { _wrap_ActionDescription_dispatchDimension_get, _wrap_ActionDescription_dispatchDimension_set };
static SwigPyGetSet ActionDescription_dispatchThreadsDimension_getset = { _wrap_ActionDescription_dispatchThreadsDimension_get, _wrap_ActionDescription_dispatchThreadsDimension_set };
static SwigPyGetSet ActionDescription_previous_getset = { _wrap_ActionDescription_previous_get, _wrap_ActionDescription_previous_set };
static SwigPyGetSet ActionDescription_dispatchBase_getset = { _wrap_ActionDescription_dispatchBase_get, _wrap_ActionDescription_dispatchBase_set };
static SwigPyGetSet ActionDescription_baseVertex_getset = { _wrap_ActionDescription_baseVertex_get, _wrap_ActionDescription_baseVertex_set };
static SwigPyGetSet ActionDescription_customName_getset = { _wrap_ActionDescription_customName_get, _wrap_ActionDescription_customName_set };
static SwigPyGetSet ActionDescription_drawIndex_getset = { _wrap_ActionDescription_drawIndex_get, _wrap_ActionDescription_drawIndex_set };
static SwigPyGetSet ActionDescription___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ActionDescription_eventId_getset = { _wrap_ActionDescription_eventId_get, _wrap_ActionDescription_eventId_set };
static SwigPyGetSet ActionDescription_copyDestination_getset = { _wrap_ActionDescription_copyDestination_get, _wrap_ActionDescription_copyDestination_set };
static SwigPyGetSet ActionDescription_numIndices_getset = { _wrap_ActionDescription_numIndices_get, _wrap_ActionDescription_numIndices_set };
static SwigPyGetSet ActionDescription_instanceOffset_getset = { _wrap_ActionDescription_instanceOffset_get, _wrap_ActionDescription_instanceOffset_set };
static SwigPyGetSet ActionDescription_copySource_getset = { _wrap_ActionDescription_copySource_get, _wrap_ActionDescription_copySource_set };
static SwigPyGetSet ActionDescription_outputs_getset = { _wrap_ActionDescription_outputs_get, _wrap_ActionDescription_outputs_set };
static SwigPyGetSet ActionDescription_flags_getset = { _wrap_ActionDescription_flags_get, _wrap_ActionDescription_flags_set };
static SwigPyGetSet ActionDescription_next_getset = { _wrap_ActionDescription_next_get, _wrap_ActionDescription_next_set };
static SwigPyGetSet ActionDescription_indexOffset_getset = { _wrap_ActionDescription_indexOffset_get, _wrap_ActionDescription_indexOffset_set };
static SwigPyGetSet ActionDescription_vertexOffset_getset = { _wrap_ActionDescription_vertexOffset_get, _wrap_ActionDescription_vertexOffset_set };
static SwigPyGetSet ActionDescription_copySourceSubresource_getset = { _wrap_ActionDescription_copySourceSubresource_get, _wrap_ActionDescription_copySourceSubresource_set };
static SwigPyGetSet ActionDescription_copyDestinationSubresource_getset = { _wrap_ActionDescription_copyDestinationSubresource_get, _wrap_ActionDescription_copyDestinationSubresource_set };
static SwigPyGetSet ActionDescription_depthOut_getset = { _wrap_ActionDescription_depthOut_get, _wrap_ActionDescription_depthOut_set };
static SwigPyGetSet ActionDescription_children_getset = { _wrap_ActionDescription_children_get, _wrap_ActionDescription_children_set };
static SwigPyGetSet ActionDescription_events_getset = { _wrap_ActionDescription_events_get, _wrap_ActionDescription_events_set };
static SwigPyGetSet ActionDescription_parent_getset = { _wrap_ActionDescription_parent_get, _wrap_ActionDescription_parent_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ActionDescription_getset[] = {
    { (char *) "markerColor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A RGBA color specified by a debug marker call.\n"
		"\n"
		":type: FloatVector\n"
		"\n"
		"", (void *) &ActionDescription_markerColor_getset }
,
    { (char *) "numInstances", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of instances for a draw action. 0 if not used.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ActionDescription_numInstances_getset }
,
    { (char *) "actionId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A 1-based index of this action relative to other actions.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ActionDescription_actionId_getset }
,
    { (char *) "dispatchDimension", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The 3D number of workgroups to dispatch in a dispatch call.\n"
		"\n"
		":type: Tuple[int,int,int]\n"
		"\n"
		"", (void *) &ActionDescription_dispatchDimension_getset }
,
    { (char *) "dispatchThreadsDimension", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The 3D size of each workgroup in threads if the call allows an override, or 0 if not.\n"
		"\n"
		":type: Tuple[int,int,int]\n"
		"\n"
		"", (void *) &ActionDescription_dispatchThreadsDimension_getset }
,
    { (char *) "previous", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The previous action in the frame, or ``None`` if this is the first action in the\n"
		"frame.\n"
		"\n"
		":type: ActionDescription\n"
		"\n"
		"", (void *) &ActionDescription_previous_getset }
,
    { (char *) "dispatchBase", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The 3D base offset of the workgroup ID if the call allows an override, or 0 if not.\n"
		"\n"
		":type: Tuple[int,int,int]\n"
		"\n"
		"", (void *) &ActionDescription_dispatchBase_getset }
,
    { (char *) "baseVertex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For indexed drawcalls, the offset added to each index after fetching.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ActionDescription_baseVertex_getset }
,
    { (char *) "customName", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The custom name of this action.\n"
		"\n"
		"For markers this will be a user-provided string. In most other cases this will be empty, and the\n"
		"name can be generated using structured data. The last listed event in :data:`events` will correspond\n"
		"to the event for the overall action, and its chunk will contain a name and any parameters.\n"
		"\n"
		"Some actions will have a custom name generated for e.g. reading back and directly displaying\n"
		"indirect parameters or render pass parameters.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ActionDescription_customName_getset }
,
    { (char *) "drawIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index of this action in an call with multiple draws, e.g. an indirect action.\n"
		"\n"
		"0 if not part of a multi-action.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ActionDescription_drawIndex_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ActionDescription.__dict__", (void *) &ActionDescription___dict___getset }
,
    { (char *) "eventId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :data:`eventId <APIEvent.eventId>` that actually produced the action.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ActionDescription_eventId_getset }
,
    { (char *) "copyDestination", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` identifying the destination object in a copy, resolve or blit\n"
		"operation.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &ActionDescription_copyDestination_getset }
,
    { (char *) "numIndices", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of indices or vertices as appropriate for a draw action. 0 if not used.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ActionDescription_numIndices_getset }
,
    { (char *) "instanceOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For instanced drawcalls, the offset applied before looking up instanced vertex inputs.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ActionDescription_instanceOffset_getset }
,
    { (char *) "copySource", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` identifying the source object in a copy, resolve or blit\n"
		"operation.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &ActionDescription_copySource_getset }
,
    { (char *) "outputs", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An 8-tuple of the :class:`ResourceId` ids for the color outputs, which can be used\n"
		"for very coarse bucketing of actions into similar passes by their outputs.\n"
		"\n"
		":type: Tuple[ResourceId,...]\n"
		"\n"
		"", (void *) &ActionDescription_outputs_getset }
,
    { (char *) "flags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A set of :class:`ActionFlags` properties describing what kind of action this is.\n"
		"\n"
		":type: ActionFlags\n"
		"\n"
		"", (void *) &ActionDescription_flags_getset }
,
    { (char *) "next", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The next action in the frame, or ``None`` if this is the last action in the frame.\n"
		"\n"
		":type: ActionDescription\n"
		"\n"
		"", (void *) &ActionDescription_next_getset }
,
    { (char *) "indexOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For indexed drawcalls, the first index to fetch from the index buffer.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ActionDescription_indexOffset_getset }
,
    { (char *) "vertexOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For non-indexed drawcalls, the offset applied before looking up each vertex input.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ActionDescription_vertexOffset_getset }
,
    { (char *) "copySourceSubresource", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Which part of :data:`copySource` is used.\n"
		"\n"
		":type: Subresource\n"
		"\n"
		"", (void *) &ActionDescription_copySourceSubresource_getset }
,
    { (char *) "copyDestinationSubresource", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Which part of :data:`copyDestination` is used.\n"
		"\n"
		":type: Subresource\n"
		"\n"
		"", (void *) &ActionDescription_copyDestinationSubresource_getset }
,
    { (char *) "depthOut", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The resource used for depth output - see :data:`outputs`.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &ActionDescription_depthOut_getset }
,
    { (char *) "children", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The child actions below this one, if it's a marker region or multi-action.\n"
		"\n"
		":type: List[ActionDescription]\n"
		"\n"
		"", (void *) &ActionDescription_children_getset }
,
    { (char *) "events", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The events that happened since the previous action.\n"
		"\n"
		":type: List[APIEvent]\n"
		"\n"
		"", (void *) &ActionDescription_events_getset }
,
    { (char *) "parent", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The parent of this action, or ``None`` if there is no parent for this action.\n"
		"\n"
		":type: ActionDescription\n"
		"\n"
		"", (void *) &ActionDescription_parent_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ActionDescription_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ActionDescription___eq__(self, other); break;
    case Py_LT : result = _wrap_ActionDescription___lt__(self, other); break;
    case Py_NE : result = _wrap_ActionDescription___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ActionDescription_methods[] = {
  { "IsFakeMarker", (PyCFunction) _wrap_ActionDescription_IsFakeMarker, METH_NOARGS, (char *) "\n"
		"IsFakeMarker()\n"
		"\n"
		"Returns whether or not this action corresponds to a fake marker added by\n"
		":meth:`ReplayController.AddFakeMarkers`.\n"
		"\n"
		"Such actions may break expectations of event IDs and action IDs, so it is recommended to avoid\n"
		"processing them wherever possible.\n"
		"\n"
		":return: Returns whether or not this action is a fake marker.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "GetName", (PyCFunction) _wrap_ActionDescription_GetName, METH_O, (char *) "\n"
		"GetName(structuredFile)\n"
		"\n"
		"Returns the name for this action, either from its custom name (see :data:`customName`)\n"
		"or from the matching chunk in the structured data passed in.\n"
		"\n"
		":param SDFile structuredFile: The structured data file for the capture this action is from.\n"
		":return: Returns the best available name for this action.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "__lt__", (PyCFunction) _wrap_ActionDescription___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ActionDescription___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_ActionDescription___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ActionDescription_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ActionDescription",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ActionDescription_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ActionDescription_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__ActionDescription_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__ActionDescription_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ActionDescription_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Describes the properties of an action.\n"
		"\n"
		"An action is a call such as a draw, a compute dispatch, clears, copies, resolves, etc. Any GPU event\n"
		"which may have deliberate visible side-effects to application-visible memory, typically resources\n"
		"such as textures and buffers. It also includes markers, which provide a user-generated annotation of\n"
		"events and actions.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ActionDescription_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ActionDescription_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ActionDescription_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ActionDescription,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ActionDescription_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ActionDescription_type};

static SwigPyGetSet APIProperties_degraded_getset = { _wrap_APIProperties_degraded_get, _wrap_APIProperties_degraded_set };
static SwigPyGetSet APIProperties_rgpCapture_getset = { _wrap_APIProperties_rgpCapture_get, _wrap_APIProperties_rgpCapture_set };
static SwigPyGetSet APIProperties_pixelHistory_getset = { _wrap_APIProperties_pixelHistory_get, _wrap_APIProperties_pixelHistory_set };
static SwigPyGetSet APIProperties_remoteReplay_getset = { _wrap_APIProperties_remoteReplay_get, _wrap_APIProperties_remoteReplay_set };
static SwigPyGetSet APIProperties___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet APIProperties_pipelineType_getset = { _wrap_APIProperties_pipelineType_get, _wrap_APIProperties_pipelineType_set };
static SwigPyGetSet APIProperties_shaderDebugging_getset = { _wrap_APIProperties_shaderDebugging_get, _wrap_APIProperties_shaderDebugging_set };
static SwigPyGetSet APIProperties_vendor_getset = { _wrap_APIProperties_vendor_get, _wrap_APIProperties_vendor_set };
static SwigPyGetSet APIProperties_localRenderer_getset = { _wrap_APIProperties_localRenderer_get, _wrap_APIProperties_localRenderer_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__APIProperties_getset[] = {
    { (char *) "degraded", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the capture was loaded successfully but running in a degraded mode - e.g.\n"
		"with software rendering, or with some functionality disabled due to lack of support.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &APIProperties_degraded_getset }
,
    { (char *) "rgpCapture", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the driver and system are configured to allow creating RGP captures.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &APIProperties_rgpCapture_getset }
,
    { (char *) "pixelHistory", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the API supports viewing pixel history.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &APIProperties_pixelHistory_getset }
,
    { (char *) "remoteReplay", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the capture is being replayed over a remote connection.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &APIProperties_remoteReplay_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"APIProperties.__dict__", (void *) &APIProperties___dict___getset }
,
    { (char *) "pipelineType", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`GraphicsAPI` of the actual log/capture.\n"
		"\n"
		":type: GraphicsAPI\n"
		"\n"
		"", (void *) &APIProperties_pipelineType_getset }
,
    { (char *) "shaderDebugging", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the API supports shader debugging.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &APIProperties_shaderDebugging_getset }
,
    { (char *) "vendor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`GPUVendor` of the active GPU being used.\n"
		"\n"
		":type: GPUVendor\n"
		"\n"
		"", (void *) &APIProperties_vendor_getset }
,
    { (char *) "localRenderer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`GraphicsAPI` used to render the log. For remote replay this could be\n"
		"different to the above, and lets the UI make decisions e.g. to flip rendering of images.\n"
		"\n"
		":type: GraphicsAPI\n"
		"\n"
		"", (void *) &APIProperties_localRenderer_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__APIProperties_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__APIProperties_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__APIProperties_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.APIProperties",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_APIProperties_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__APIProperties_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__APIProperties_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__APIProperties_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__APIProperties_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Gives some API-specific information about the capture.",     /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__APIProperties_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__APIProperties_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__APIProperties_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_APIProperties,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__APIProperties_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__APIProperties_type};

static SwigPyGetSet DriverInformation___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet DriverInformation_version_getset = { _wrap_DriverInformation_version_get, _wrap_DriverInformation_version_set };
static SwigPyGetSet DriverInformation_vendor_getset = { _wrap_DriverInformation_vendor_get, _wrap_DriverInformation_vendor_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DriverInformation_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DriverInformation.__dict__", (void *) &DriverInformation___dict___getset }
,
    { (char *) "version", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The version string for the driver\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &DriverInformation_version_getset }
,
    { (char *) "vendor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`GPUVendor` that provides this driver\n"
		"\n"
		":type: GPUVendor\n"
		"\n"
		"", (void *) &DriverInformation_vendor_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DriverInformation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DriverInformation_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DriverInformation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.DriverInformation",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DriverInformation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DriverInformation_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__DriverInformation_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__DriverInformation_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DriverInformation_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Gives information about the driver for this API.",           /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DriverInformation_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DriverInformation_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DriverInformation_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DriverInformation,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DriverInformation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DriverInformation_type};

static SwigPyGetSet Uuid___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet Uuid_words_getset = { _wrap_Uuid_words_get, _wrap_Uuid_words_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__Uuid_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"Uuid.__dict__", (void *) &Uuid___dict___getset }
,
    { (char *) "words", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The Uuid bytes as a tuple of four 32-bit integers.\n"
		"\n"
		":type: Tuple[int,int,int,int]\n"
		"\n"
		"", (void *) &Uuid_words_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__Uuid_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_Uuid___eq__(self, other); break;
    case Py_LT : result = _wrap_Uuid___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__Uuid_methods[] = {
  { "__lt__", (PyCFunction) _wrap_Uuid___lt__, METH_O, (char *) "\n"
		"__lt__(rhs)\n"
		"\n"
		"Compares two ``Uuid`` objects for less-than.\n"
		"" },
  { "__eq__", (PyCFunction) _wrap_Uuid___eq__, METH_O, (char *) "\n"
		"__eq__(rhs)\n"
		"\n"
		"Compares two ``Uuid`` objects for equality.\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__Uuid_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.Uuid",                         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_Uuid_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__Uuid_type.as_number,      /* tp_as_number */
    &SwigPyBuiltin__Uuid_type.as_sequence,    /* tp_as_sequence */
    &SwigPyBuiltin__Uuid_type.as_mapping,     /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__Uuid_type.as_buffer,      /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A 128-bit Uuid.",                        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__Uuid_richcompare,                /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__Uuid_methods,              /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__Uuid_getset,               /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_Uuid,                /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__Uuid_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__Uuid_type};

static SwigPyGetSet CounterDescription_uuid_getset = { _wrap_CounterDescription_uuid_get, _wrap_CounterDescription_uuid_set };
static SwigPyGetSet CounterDescription_name_getset = { _wrap_CounterDescription_name_get, _wrap_CounterDescription_name_set };
static SwigPyGetSet CounterDescription_counter_getset = { _wrap_CounterDescription_counter_get, _wrap_CounterDescription_counter_set };
static SwigPyGetSet CounterDescription_resultType_getset = { _wrap_CounterDescription_resultType_get, _wrap_CounterDescription_resultType_set };
static SwigPyGetSet CounterDescription_unit_getset = { _wrap_CounterDescription_unit_get, _wrap_CounterDescription_unit_set };
static SwigPyGetSet CounterDescription___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet CounterDescription_category_getset = { _wrap_CounterDescription_category_get, _wrap_CounterDescription_category_set };
static SwigPyGetSet CounterDescription_description_getset = { _wrap_CounterDescription_description_get, _wrap_CounterDescription_description_set };
static SwigPyGetSet CounterDescription_resultByteWidth_getset = { _wrap_CounterDescription_resultByteWidth_get, _wrap_CounterDescription_resultByteWidth_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CounterDescription_getset[] = {
    { (char *) "uuid", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The unique identifier for this counter that will not change across drivers or replays.\n"
		"\n"
		":type: Uuid\n"
		"\n"
		"", (void *) &CounterDescription_uuid_getset }
,
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A short human-readable name for the counter.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &CounterDescription_name_getset }
,
    { (char *) "counter", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`GPUCounter` this counter represents.\n"
		"\n"
		".. note:: This is stored as an ``int`` not a :class:`GPUCounter` to allow for values that may not\n"
		"  correspond to any of the predefined values if it's a hardware-specific counter value.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &CounterDescription_counter_getset }
,
    { (char *) "resultType", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`type of value <CompType>` returned by this counter.\n"
		"\n"
		":type: CompType\n"
		"\n"
		"", (void *) &CounterDescription_resultType_getset }
,
    { (char *) "unit", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`CounterUnit` for the result value.\n"
		"\n"
		":type: CounterUnit\n"
		"\n"
		"", (void *) &CounterDescription_unit_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"CounterDescription.__dict__", (void *) &CounterDescription___dict___getset }
,
    { (char *) "category", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The counter category. Can be empty for uncategorized counters.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &CounterDescription_category_getset }
,
    { (char *) "description", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If available, a longer human-readable description of the value this counter measures.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &CounterDescription_description_getset }
,
    { (char *) "resultByteWidth", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of bytes in the resulting value.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &CounterDescription_resultByteWidth_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__CounterDescription_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__CounterDescription_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__CounterDescription_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.CounterDescription",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_CounterDescription_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__CounterDescription_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__CounterDescription_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__CounterDescription_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__CounterDescription_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a GPU counter's purpose and result value.",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__CounterDescription_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__CounterDescription_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__CounterDescription_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_CounterDescription,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__CounterDescription_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CounterDescription_type};

static SwigPyGetSet CounterValue_f_getset = { _wrap_CounterValue_f_get, _wrap_CounterValue_f_set };
static SwigPyGetSet CounterValue_u64_getset = { _wrap_CounterValue_u64_get, _wrap_CounterValue_u64_set };
static SwigPyGetSet CounterValue___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet CounterValue_u32_getset = { _wrap_CounterValue_u32_get, _wrap_CounterValue_u32_set };
static SwigPyGetSet CounterValue_d_getset = { _wrap_CounterValue_d_get, _wrap_CounterValue_d_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CounterValue_getset[] = {
    { (char *) "f", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A ``float`` value.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &CounterValue_f_getset }
,
    { (char *) "u64", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A 64-bit unsigned integer.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &CounterValue_u64_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"CounterValue.__dict__", (void *) &CounterValue___dict___getset }
,
    { (char *) "u32", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A 32-bit unsigned integer.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &CounterValue_u32_getset }
,
    { (char *) "d", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A ``double`` value.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &CounterValue_d_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__CounterValue_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__CounterValue_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__CounterValue_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.CounterValue",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_CounterValue_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__CounterValue_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__CounterValue_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__CounterValue_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__CounterValue_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A resulting value from a GPU counter. Only one member is valid, see\n"
		":class:`CounterDescription`.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__CounterValue_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__CounterValue_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__CounterValue_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_CounterValue,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__CounterValue_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CounterValue_type};

static SwigPyGetSet CounterResult_value_getset = { _wrap_CounterResult_value_get, _wrap_CounterResult_value_set };
static SwigPyGetSet CounterResult_counter_getset = { _wrap_CounterResult_counter_get, _wrap_CounterResult_counter_set };
static SwigPyGetSet CounterResult___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet CounterResult_eventId_getset = { _wrap_CounterResult_eventId_get, _wrap_CounterResult_eventId_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CounterResult_getset[] = {
    { (char *) "value", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value itself.\n"
		"\n"
		":type: CounterValue\n"
		"\n"
		"", (void *) &CounterResult_value_getset }
,
    { (char *) "counter", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :data:`counter <GPUCounter>` that produced this value, stored as an int.\n"
		"\n"
		".. note:: This is stored as an ``int`` not a :class:`GPUCounter` to allow for values that may not\n"
		"  correspond to any of the predefined values if it's a hardware-specific counter value.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &CounterResult_counter_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"CounterResult.__dict__", (void *) &CounterResult___dict___getset }
,
    { (char *) "eventId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :data:`eventId <APIEvent.eventId>` that produced this value.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &CounterResult_eventId_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__CounterResult_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_CounterResult___eq__(self, other); break;
    case Py_LT : result = _wrap_CounterResult___lt__(self, other); break;
    case Py_NE : result = _wrap_CounterResult___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__CounterResult_methods[] = {
  { "__lt__", (PyCFunction) _wrap_CounterResult___lt__, METH_O, (char *) "\n"
		"__lt__(o)\n"
		"\n"
		"Compares two ``CounterResult`` objects for less-than.\n"
		"" },
  { "__eq__", (PyCFunction) _wrap_CounterResult___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_CounterResult___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__CounterResult_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.CounterResult",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_CounterResult_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__CounterResult_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__CounterResult_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__CounterResult_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__CounterResult_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The resulting value from a counter at an event.",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__CounterResult_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__CounterResult_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__CounterResult_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_CounterResult,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__CounterResult_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CounterResult_type};

static SwigPyGetSet PixelValue_uintValue_getset = { _wrap_PixelValue_uintValue_get, _wrap_PixelValue_uintValue_set };
static SwigPyGetSet PixelValue_intValue_getset = { _wrap_PixelValue_intValue_get, _wrap_PixelValue_intValue_set };
static SwigPyGetSet PixelValue_floatValue_getset = { _wrap_PixelValue_floatValue_get, _wrap_PixelValue_floatValue_set };
static SwigPyGetSet PixelValue___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__PixelValue_getset[] = {
    { (char *) "uintValue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The RGBA value interpreted as 32-bit unsigned integer.\n"
		"\n"
		":type: Tuple[int, int, int, int]\n"
		"\n"
		"", (void *) &PixelValue_uintValue_getset }
,
    { (char *) "intValue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The RGBA value interpreted as 32-bit signed integer.\n"
		"\n"
		":type: Tuple[int, int, int, int]\n"
		"\n"
		"", (void *) &PixelValue_intValue_getset }
,
    { (char *) "floatValue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The RGBA value interpreted as ``float``.\n"
		"\n"
		":type: Tuple[float, float, float, float]\n"
		"\n"
		"", (void *) &PixelValue_floatValue_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"PixelValue.__dict__", (void *) &PixelValue___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__PixelValue_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__PixelValue_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__PixelValue_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.PixelValue",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_PixelValue_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__PixelValue_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__PixelValue_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__PixelValue_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__PixelValue_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The contents of an RGBA pixel.",         /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__PixelValue_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__PixelValue_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__PixelValue_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_PixelValue,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__PixelValue_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__PixelValue_type};

static SwigPyGetSet ModificationValue___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ModificationValue_depth_getset = { _wrap_ModificationValue_depth_get, _wrap_ModificationValue_depth_set };
static SwigPyGetSet ModificationValue_col_getset = { _wrap_ModificationValue_col_get, _wrap_ModificationValue_col_set };
static SwigPyGetSet ModificationValue_stencil_getset = { _wrap_ModificationValue_stencil_get, _wrap_ModificationValue_stencil_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ModificationValue_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ModificationValue.__dict__", (void *) &ModificationValue___dict___getset }
,
    { (char *) "depth", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The depth value.\n"
		"\n"
		"If depth is not available/in-use for this modification, it will be ``-1.0``.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &ModificationValue_depth_getset }
,
    { (char *) "col", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The color value.\n"
		"\n"
		"If the modifications are for a color target, tthe contents will all be ``0``.\n"
		"\n"
		":type: PixelValue\n"
		"\n"
		"", (void *) &ModificationValue_col_getset }
,
    { (char *) "stencil", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stencil value.\n"
		"\n"
		"If stencil is not available for this modification, it will be negative. If stencil is not available\n"
		"at all and not in use then the stencil value will be ``-1``. If stencil was in use but can't be\n"
		"determined due to the pixel history implementation using stencil for its own purposes, the value\n"
		"will be ``-2``. This will only happen when looking at multiple modifications from the same event.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ModificationValue_stencil_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ModificationValue_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ModificationValue___eq__(self, other); break;
    case Py_LT : result = _wrap_ModificationValue___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ModificationValue_methods[] = {
  { "__eq__", (PyCFunction) _wrap_ModificationValue___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_ModificationValue___lt__, METH_O, (char *) "__lt__(o)" },
  { "IsValid", (PyCFunction) _wrap_ModificationValue_IsValid, METH_NOARGS, (char *) "\n"
		"IsValid()\n"
		"\n"
		"\n"
		":return: Returns whether or not this modification value is valid.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "SetInvalid", (PyCFunction) _wrap_ModificationValue_SetInvalid, METH_NOARGS, (char *) "\n"
		"SetInvalid()\n"
		"\n"
		"Sets this modification value to be invalid.\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ModificationValue_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ModificationValue",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ModificationValue_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ModificationValue_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__ModificationValue_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__ModificationValue_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ModificationValue_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The value of pixel output at a particular event.",           /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ModificationValue_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ModificationValue_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ModificationValue_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ModificationValue,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ModificationValue_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ModificationValue_type};

static SwigPyGetSet PixelModification_depthTestFailed_getset = { _wrap_PixelModification_depthTestFailed_get, _wrap_PixelModification_depthTestFailed_set };
static SwigPyGetSet PixelModification_stencilTestFailed_getset = { _wrap_PixelModification_stencilTestFailed_get, _wrap_PixelModification_stencilTestFailed_set };
static SwigPyGetSet PixelModification_postMod_getset = { _wrap_PixelModification_postMod_get, _wrap_PixelModification_postMod_set };
static SwigPyGetSet PixelModification_directShaderWrite_getset = { _wrap_PixelModification_directShaderWrite_get, _wrap_PixelModification_directShaderWrite_set };
static SwigPyGetSet PixelModification_preMod_getset = { _wrap_PixelModification_preMod_get, _wrap_PixelModification_preMod_set };
static SwigPyGetSet PixelModification___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet PixelModification_eventId_getset = { _wrap_PixelModification_eventId_get, _wrap_PixelModification_eventId_set };
static SwigPyGetSet PixelModification_fragIndex_getset = { _wrap_PixelModification_fragIndex_get, _wrap_PixelModification_fragIndex_set };
static SwigPyGetSet PixelModification_shaderOut_getset = { _wrap_PixelModification_shaderOut_get, _wrap_PixelModification_shaderOut_set };
static SwigPyGetSet PixelModification_shaderDiscarded_getset = { _wrap_PixelModification_shaderDiscarded_get, _wrap_PixelModification_shaderDiscarded_set };
static SwigPyGetSet PixelModification_sampleMasked_getset = { _wrap_PixelModification_sampleMasked_get, _wrap_PixelModification_sampleMasked_set };
static SwigPyGetSet PixelModification_depthBoundsFailed_getset = { _wrap_PixelModification_depthBoundsFailed_get, _wrap_PixelModification_depthBoundsFailed_set };
static SwigPyGetSet PixelModification_predicationSkipped_getset = { _wrap_PixelModification_predicationSkipped_get, _wrap_PixelModification_predicationSkipped_set };
static SwigPyGetSet PixelModification_primitiveID_getset = { _wrap_PixelModification_primitiveID_get, _wrap_PixelModification_primitiveID_set };
static SwigPyGetSet PixelModification_backfaceCulled_getset = { _wrap_PixelModification_backfaceCulled_get, _wrap_PixelModification_backfaceCulled_set };
static SwigPyGetSet PixelModification_unboundPS_getset = { _wrap_PixelModification_unboundPS_get, _wrap_PixelModification_unboundPS_set };
static SwigPyGetSet PixelModification_depthClipped_getset = { _wrap_PixelModification_depthClipped_get, _wrap_PixelModification_depthClipped_set };
static SwigPyGetSet PixelModification_viewClipped_getset = { _wrap_PixelModification_viewClipped_get, _wrap_PixelModification_viewClipped_set };
static SwigPyGetSet PixelModification_scissorClipped_getset = { _wrap_PixelModification_scissorClipped_get, _wrap_PixelModification_scissorClipped_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__PixelModification_getset[] = {
    { (char *) "depthTestFailed", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth testing eliminated this fragment.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &PixelModification_depthTestFailed_getset }
,
    { (char *) "stencilTestFailed", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if stencil testing eliminated this fragment.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &PixelModification_stencilTestFailed_getset }
,
    { (char *) "postMod", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value of the texture after this fragment ran.\n"
		"\n"
		":type: ModificationValue\n"
		"\n"
		"", (void *) &PixelModification_postMod_getset }
,
    { (char *) "directShaderWrite", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this event came as part of an arbitrary shader write.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &PixelModification_directShaderWrite_getset }
,
    { (char *) "preMod", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value of the texture before this fragment ran.\n"
		"\n"
		"This is valid only for the first fragment if multiple fragments in the same event write to the same\n"
		"pixel.\n"
		"\n"
		":type: ModificationValue\n"
		"\n"
		"", (void *) &PixelModification_preMod_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"PixelModification.__dict__", (void *) &PixelModification___dict___getset }
,
    { (char *) "eventId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :data:`eventId <APIEvent.eventId>` where the modification happened.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &PixelModification_eventId_getset }
,
    { (char *) "fragIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A 0-based index of which fragment this modification corresponds to, in the case that\n"
		"multiple fragments from a single action wrote to a pixel.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &PixelModification_fragIndex_getset }
,
    { (char *) "shaderOut", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value that this fragment wrote from the pixel shader.\n"
		"\n"
		":type: ModificationValue\n"
		"\n"
		"", (void *) &PixelModification_shaderOut_getset }
,
    { (char *) "shaderDiscarded", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the pixel shader executed a discard on this fragment.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &PixelModification_shaderDiscarded_getset }
,
    { (char *) "sampleMasked", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the sample mask eliminated this fragment.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &PixelModification_sampleMasked_getset }
,
    { (char *) "depthBoundsFailed", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth bounds clipping eliminated this fragment.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &PixelModification_depthBoundsFailed_getset }
,
    { (char *) "predicationSkipped", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if predicated rendering skipped this call.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &PixelModification_predicationSkipped_getset }
,
    { (char *) "primitiveID", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The primitive that generated this fragment.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &PixelModification_primitiveID_getset }
,
    { (char *) "backfaceCulled", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the backface culling test eliminated this fragment.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &PixelModification_backfaceCulled_getset }
,
    { (char *) "unboundPS", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if no pixel shader was bound at this event. On D3D APIs this may also mean\n"
		"a pixel shader exists but declares no output for the corresponding target and so is skipped.\n"
		"\n"
		"On other APIs this is only reported if the pixel shader is entirely unbound but this means the\n"
		"output may have undefined values.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &PixelModification_unboundPS_getset }
,
    { (char *) "depthClipped", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth near/far clipping eliminated this fragment.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &PixelModification_depthClipped_getset }
,
    { (char *) "viewClipped", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if viewport clipping eliminated this fragment.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &PixelModification_viewClipped_getset }
,
    { (char *) "scissorClipped", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if scissor clipping eliminated this fragment.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &PixelModification_scissorClipped_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__PixelModification_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_PixelModification___eq__(self, other); break;
    case Py_LT : result = _wrap_PixelModification___lt__(self, other); break;
    case Py_NE : result = _wrap_PixelModification___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__PixelModification_methods[] = {
  { "__lt__", (PyCFunction) _wrap_PixelModification___lt__, METH_O, (char *) "__lt__(o)" },
  { "Passed", (PyCFunction) _wrap_PixelModification_Passed, METH_NOARGS, (char *) "\n"
		"Passed()\n"
		"\n"
		"Determine if this fragment passed all tests and wrote to the texture.\n"
		"\n"
		":return: ``True`` if it passed all tests, ``False`` if it failed any.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "CheckDepthTestQuantised", (PyCFunction) _wrap_PixelModification_CheckDepthTestQuantised, METH_VARARGS, (char *) "\n"
		"CheckDepthTestQuantised(depthBits, depthFunc)\n"
		"\n"
		"Update the depth-test failure state based on known shader output depth value and\n"
		"preMod reference value, quantised to a certain number of depth bits with epsilon.\n"
		"\n"
		"This is primarily used internally and should not be needed to be called externally.\n"
		"\n"
		":param int depthBits: How many bits are in the depth buffer: 16, 24 or 32.\n"
		":param CompareFunction depthFunc: The comparison function active for the depth test\n"
		"\n"
		"" },
  { "__eq__", (PyCFunction) _wrap_PixelModification___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_PixelModification___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__PixelModification_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.PixelModification",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_PixelModification_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__PixelModification_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__PixelModification_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__PixelModification_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__PixelModification_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "An attempt to modify a pixel by a particular event.",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__PixelModification_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__PixelModification_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__PixelModification_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_PixelModification,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__PixelModification_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__PixelModification_type};

static SwigPyGetSet Thumbnail_height_getset = { _wrap_Thumbnail_height_get, _wrap_Thumbnail_height_set };
static SwigPyGetSet Thumbnail___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet Thumbnail_width_getset = { _wrap_Thumbnail_width_get, _wrap_Thumbnail_width_set };
static SwigPyGetSet Thumbnail_type_getset = { _wrap_Thumbnail_type_get, _wrap_Thumbnail_type_set };
static SwigPyGetSet Thumbnail_data_getset = { _wrap_Thumbnail_data_get, _wrap_Thumbnail_data_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__Thumbnail_getset[] = {
    { (char *) "height", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The height of the thumbnail image.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Thumbnail_height_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"Thumbnail.__dict__", (void *) &Thumbnail___dict___getset }
,
    { (char *) "width", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The width of the thumbnail image.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &Thumbnail_width_getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`FileType` of the data in the thumbnail.\n"
		"\n"
		":type: FileType\n"
		"\n"
		"", (void *) &Thumbnail_type_getset }
,
    { (char *) "data", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The ``bytes`` byte array containing the raw data.\n"
		"\n"
		":type: bytes\n"
		"\n"
		"", (void *) &Thumbnail_data_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__Thumbnail_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__Thumbnail_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__Thumbnail_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.Thumbnail",                    /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_Thumbnail_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__Thumbnail_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__Thumbnail_type.as_sequence,                   /* tp_as_sequence */
    &SwigPyBuiltin__Thumbnail_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__Thumbnail_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the bytes and metadata describing a thumbnail.",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__Thumbnail_richcompare,           /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__Thumbnail_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__Thumbnail_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_Thumbnail,           /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__Thumbnail_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__Thumbnail_type};

static SwigPyGetSet DebugPixelInputs_view_getset = { _wrap_DebugPixelInputs_view_get, _wrap_DebugPixelInputs_view_set };
static SwigPyGetSet DebugPixelInputs___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet DebugPixelInputs_primitive_getset = { _wrap_DebugPixelInputs_primitive_get, _wrap_DebugPixelInputs_primitive_set };
static SwigPyGetSet DebugPixelInputs_sample_getset = { _wrap_DebugPixelInputs_sample_get, _wrap_DebugPixelInputs_sample_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DebugPixelInputs_getset[] = {
    { (char *) "view", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The layered or multiview rendering view index.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DebugPixelInputs_view_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DebugPixelInputs.__dict__", (void *) &DebugPixelInputs___dict___getset }
,
    { (char *) "primitive", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The primitive index.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DebugPixelInputs_primitive_getset }
,
    { (char *) "sample", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The multi-sampled sample.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DebugPixelInputs_sample_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DebugPixelInputs_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DebugPixelInputs_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DebugPixelInputs_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.DebugPixelInputs",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DebugPixelInputs_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DebugPixelInputs_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__DebugPixelInputs_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__DebugPixelInputs_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DebugPixelInputs_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the properties used to select which fragment to debug, used as an input to DebugPixel.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DebugPixelInputs_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DebugPixelInputs_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DebugPixelInputs_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DebugPixelInputs,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DebugPixelInputs_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DebugPixelInputs_type};

static SwigPyGetSet GLVertexAttribute_enabled_getset = { _wrap_GLVertexAttribute_enabled_get, _wrap_GLVertexAttribute_enabled_set };
static SwigPyGetSet GLVertexAttribute_genericValue_getset = { _wrap_GLVertexAttribute_genericValue_get, _wrap_GLVertexAttribute_genericValue_set };
static SwigPyGetSet GLVertexAttribute_format_getset = { _wrap_GLVertexAttribute_format_get, _wrap_GLVertexAttribute_format_set };
static SwigPyGetSet GLVertexAttribute___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLVertexAttribute_boundShaderInput_getset = { _wrap_GLVertexAttribute_boundShaderInput_get, _wrap_GLVertexAttribute_boundShaderInput_set };
static SwigPyGetSet GLVertexAttribute_byteOffset_getset = { _wrap_GLVertexAttribute_byteOffset_get, _wrap_GLVertexAttribute_byteOffset_set };
static SwigPyGetSet GLVertexAttribute_vertexBufferSlot_getset = { _wrap_GLVertexAttribute_vertexBufferSlot_get, _wrap_GLVertexAttribute_vertexBufferSlot_set };
static SwigPyGetSet GLVertexAttribute_floatCast_getset = { _wrap_GLVertexAttribute_floatCast_get, _wrap_GLVertexAttribute_floatCast_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__VertexAttribute_getset[] = {
    { (char *) "enabled", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this vertex attribute is enabled.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLVertexAttribute_enabled_getset }
,
    { (char *) "genericValue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The generic value of the vertex attribute if no buffer is bound.\n"
		"\n"
		":type: PixelValue\n"
		"\n"
		"", (void *) &GLVertexAttribute_genericValue_getset }
,
    { (char *) "format", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The format describing how the vertex attribute is interpreted.\n"
		"\n"
		":type: ResourceFormat\n"
		"\n"
		"", (void *) &GLVertexAttribute_format_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::VertexAttribute.__dict__", (void *) &GLVertexAttribute___dict___getset }
,
    { (char *) "boundShaderInput", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"This lists which shader input is bound to this attribute, as an index in the\n"
		":data:`ShaderReflection.inputSignature` list.\n"
		"\n"
		"If any value is set to ``-1`` then the attribute is unbound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GLVertexAttribute_boundShaderInput_getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset from the start of the vertex data in the vertex buffer from\n"
		":data:`vertexBufferSlot`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GLVertexAttribute_byteOffset_getset }
,
    { (char *) "vertexBufferSlot", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex buffer input slot where the data is sourced from.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GLVertexAttribute_vertexBufferSlot_getset }
,
    { (char *) "floatCast", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Only valid for integer formatted attributes, ``True`` if they are cast to float.\n"
		"\n"
		"This is because they were specified with an integer format but glVertexAttribFormat (not\n"
		"glVertexAttribIFormat) so they will be cast.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLVertexAttribute_floatCast_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__VertexAttribute_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_GLVertexAttribute___eq__(self, other); break;
    case Py_LT : result = _wrap_GLVertexAttribute___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__VertexAttribute_methods[] = {
  { "__eq__", (PyCFunction) _wrap_GLVertexAttribute___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_GLVertexAttribute___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__VertexAttribute_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLVertexAttribute",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLVertexAttribute_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__VertexAttribute_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__GLPipe__VertexAttribute_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__VertexAttribute_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__VertexAttribute_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Describes the configuration for a single vertex attribute.\n"
		"\n"
		".. note:: If old-style vertex attrib pointer setup was used for the vertex attributes then it will\n"
		"  be decomposed into 1:1 attributes and buffers.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__VertexAttribute_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__VertexAttribute_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__VertexAttribute_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLVertexAttribute,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__VertexAttribute_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__VertexAttribute_type};

static SwigPyGetSet GLVertexBuffer_instanceDivisor_getset = { _wrap_GLVertexBuffer_instanceDivisor_get, _wrap_GLVertexBuffer_instanceDivisor_set };
static SwigPyGetSet GLVertexBuffer_resourceId_getset = { _wrap_GLVertexBuffer_resourceId_get, _wrap_GLVertexBuffer_resourceId_set };
static SwigPyGetSet GLVertexBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLVertexBuffer_byteStride_getset = { _wrap_GLVertexBuffer_byteStride_get, _wrap_GLVertexBuffer_byteStride_set };
static SwigPyGetSet GLVertexBuffer_byteOffset_getset = { _wrap_GLVertexBuffer_byteOffset_get, _wrap_GLVertexBuffer_byteOffset_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__VertexBuffer_getset[] = {
    { (char *) "instanceDivisor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The instance rate divisor.\n"
		"\n"
		"If this is ``0`` then the vertex buffer is read at vertex rate.\n"
		"\n"
		"If it's ``1`` then one element is read for each instance, and for ``N`` greater than ``1`` then\n"
		"``N`` instances read the same element before advancing.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GLVertexBuffer_instanceDivisor_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the buffer bound to this slot.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &GLVertexBuffer_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::VertexBuffer.__dict__", (void *) &GLVertexBuffer___dict___getset }
,
    { (char *) "byteStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte stride between the start of one set of vertex data and the next.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GLVertexBuffer_byteStride_getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset from the start of the buffer to the beginning of the vertex data.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GLVertexBuffer_byteOffset_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__VertexBuffer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_GLVertexBuffer___eq__(self, other); break;
    case Py_LT : result = _wrap_GLVertexBuffer___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__VertexBuffer_methods[] = {
  { "__eq__", (PyCFunction) _wrap_GLVertexBuffer___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_GLVertexBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__VertexBuffer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLVertexBuffer",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLVertexBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__VertexBuffer_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__GLPipe__VertexBuffer_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__VertexBuffer_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__VertexBuffer_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a single OpenGL vertex buffer binding.",           /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__VertexBuffer_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__VertexBuffer_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__VertexBuffer_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLVertexBuffer,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__VertexBuffer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__VertexBuffer_type};

static SwigPyGetSet GLVertexInput_attributes_getset = { _wrap_GLVertexInput_attributes_get, _wrap_GLVertexInput_attributes_set };
static SwigPyGetSet GLVertexInput_indexBuffer_getset = { _wrap_GLVertexInput_indexBuffer_get, _wrap_GLVertexInput_indexBuffer_set };
static SwigPyGetSet GLVertexInput_primitiveRestart_getset = { _wrap_GLVertexInput_primitiveRestart_get, _wrap_GLVertexInput_primitiveRestart_set };
static SwigPyGetSet GLVertexInput_vertexBuffers_getset = { _wrap_GLVertexInput_vertexBuffers_get, _wrap_GLVertexInput_vertexBuffers_set };
static SwigPyGetSet GLVertexInput___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLVertexInput_indexByteStride_getset = { _wrap_GLVertexInput_indexByteStride_get, _wrap_GLVertexInput_indexByteStride_set };
static SwigPyGetSet GLVertexInput_topology_getset = { _wrap_GLVertexInput_topology_get, _wrap_GLVertexInput_topology_set };
static SwigPyGetSet GLVertexInput_provokingVertexLast_getset = { _wrap_GLVertexInput_provokingVertexLast_get, _wrap_GLVertexInput_provokingVertexLast_set };
static SwigPyGetSet GLVertexInput_restartIndex_getset = { _wrap_GLVertexInput_restartIndex_get, _wrap_GLVertexInput_restartIndex_set };
static SwigPyGetSet GLVertexInput_vertexArrayObject_getset = { _wrap_GLVertexInput_vertexArrayObject_get, _wrap_GLVertexInput_vertexArrayObject_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__VertexInput_getset[] = {
    { (char *) "attributes", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex attributes.\n"
		"\n"
		":type: List[GLVertexAttribute]\n"
		"\n"
		"", (void *) &GLVertexInput_attributes_getset }
,
    { (char *) "indexBuffer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the index buffer.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &GLVertexInput_indexBuffer_getset }
,
    { (char *) "primitiveRestart", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if primitive restart is enabled for strip primitives.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLVertexInput_primitiveRestart_getset }
,
    { (char *) "vertexBuffers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex buffers.\n"
		"\n"
		":type: List[GLVertexBuffer]\n"
		"\n"
		"", (void *) &GLVertexInput_vertexBuffers_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::VertexInput.__dict__", (void *) &GLVertexInput___dict___getset }
,
    { (char *) "indexByteStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte width of the index buffer - typically 1, 2 or 4 bytes. It can be 0 for\n"
		"non-indexed draws.\n"
		"\n"
		".. note::\n"
		"  This does not correspond to a real GL state since the index type is specified per-action in the call\n"
		"  itself. This is an implicit state derived from the last (or current) action at any given event.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GLVertexInput_indexByteStride_getset }
,
    { (char *) "topology", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte width of the index buffer - typically 1, 2 or 4 bytes.\n"
		"\n"
		".. note::\n"
		"  This does not correspond to a real GL state since the topology is specified per-action in the call\n"
		"  itself. This is an implicit state derived from the last (or current) action at any given event.\n"
		"\n"
		":type: Topology\n"
		"\n"
		"", (void *) &GLVertexInput_topology_getset }
,
    { (char *) "provokingVertexLast", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the provoking vertex is the last one in the primitive.\n"
		"\n"
		"``False`` if the provoking vertex is the first one.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLVertexInput_provokingVertexLast_getset }
,
    { (char *) "restartIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index value to use to indicate a strip restart.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GLVertexInput_restartIndex_getset }
,
    { (char *) "vertexArrayObject", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the vertex array object that's bound.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &GLVertexInput_vertexArrayObject_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__VertexInput_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__VertexInput_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__VertexInput_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLVertexInput",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLVertexInput_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__VertexInput_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__GLPipe__VertexInput_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__VertexInput_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__VertexInput_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the setup for fixed-function vertex input fetch.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__VertexInput_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__VertexInput_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__VertexInput_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLVertexInput,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__VertexInput_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__VertexInput_type};

static SwigPyGetSet GLShader_subroutines_getset = { _wrap_GLShader_subroutines_get, _wrap_GLShader_subroutines_set };
static SwigPyGetSet GLShader_reflection_getset = { _wrap_GLShader_reflection_get, _wrap_GLShader_reflection_set };
static SwigPyGetSet GLShader_shaderResourceId_getset = { _wrap_GLShader_shaderResourceId_get, _wrap_GLShader_shaderResourceId_set };
static SwigPyGetSet GLShader_programResourceId_getset = { _wrap_GLShader_programResourceId_get, _wrap_GLShader_programResourceId_set };
static SwigPyGetSet GLShader_stage_getset = { _wrap_GLShader_stage_get, _wrap_GLShader_stage_set };
static SwigPyGetSet GLShader___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__Shader_getset[] = {
    { (char *) "subroutines", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list of integers with the subroutine values.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &GLShader_subroutines_getset }
,
    { (char *) "reflection", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The reflection data for this shader.\n"
		"\n"
		":type: ShaderReflection\n"
		"\n"
		"", (void *) &GLShader_reflection_getset }
,
    { (char *) "shaderResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the shader object itself.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &GLShader_shaderResourceId_getset }
,
    { (char *) "programResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the program bound to this stage.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &GLShader_programResourceId_getset }
,
    { (char *) "stage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A :class:`ShaderStage` identifying which stage this shader is bound to.\n"
		"\n"
		":type: ShaderStage\n"
		"\n"
		"", (void *) &GLShader_stage_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::Shader.__dict__", (void *) &GLShader___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__Shader_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__Shader_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__Shader_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLShader",                     /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLShader_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__Shader_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__GLPipe__Shader_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__Shader_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__Shader_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes an OpenGL shader stage.",      /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__Shader_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__Shader_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__Shader_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLShader,            /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__Shader_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__Shader_type};

static SwigPyGetSet GLFixedVertexProcessing_defaultInnerLevel_getset = { _wrap_GLFixedVertexProcessing_defaultInnerLevel_get, _wrap_GLFixedVertexProcessing_defaultInnerLevel_set };
static SwigPyGetSet GLFixedVertexProcessing_defaultOuterLevel_getset = { _wrap_GLFixedVertexProcessing_defaultOuterLevel_get, _wrap_GLFixedVertexProcessing_defaultOuterLevel_set };
static SwigPyGetSet GLFixedVertexProcessing___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLFixedVertexProcessing_clipPlanes_getset = { _wrap_GLFixedVertexProcessing_clipPlanes_get, _wrap_GLFixedVertexProcessing_clipPlanes_set };
static SwigPyGetSet GLFixedVertexProcessing_clipOriginLowerLeft_getset = { _wrap_GLFixedVertexProcessing_clipOriginLowerLeft_get, _wrap_GLFixedVertexProcessing_clipOriginLowerLeft_set };
static SwigPyGetSet GLFixedVertexProcessing_discard_getset = { _wrap_GLFixedVertexProcessing_discard_get, _wrap_GLFixedVertexProcessing_discard_set };
static SwigPyGetSet GLFixedVertexProcessing_clipNegativeOneToOne_getset = { _wrap_GLFixedVertexProcessing_clipNegativeOneToOne_get, _wrap_GLFixedVertexProcessing_clipNegativeOneToOne_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__FixedVertexProcessing_getset[] = {
    { (char *) "defaultInnerLevel", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A tuple of ``float`` giving the default inner level of tessellation.\n"
		"\n"
		":type: Tuple[float,float]\n"
		"\n"
		"", (void *) &GLFixedVertexProcessing_defaultInnerLevel_getset }
,
    { (char *) "defaultOuterLevel", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A tuple of ``float`` giving the default outer level of tessellation.\n"
		"\n"
		":type: Tuple[float,float,float,float]\n"
		"\n"
		"", (void *) &GLFixedVertexProcessing_defaultOuterLevel_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::FixedVertexProcessing.__dict__", (void *) &GLFixedVertexProcessing___dict___getset }
,
    { (char *) "clipPlanes", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An 8-tuple of ``bool`` determining which user clipping planes are enabled.\n"
		"\n"
		":type: Tuple[bool,...]\n"
		"\n"
		"", (void *) &GLFixedVertexProcessing_clipPlanes_getset }
,
    { (char *) "clipOriginLowerLeft", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the clipping origin should be in the lower left.\n"
		"\n"
		"``False`` if it's in the upper left.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLFixedVertexProcessing_clipOriginLowerLeft_getset }
,
    { (char *) "discard", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if primitives should be discarded during rasterization.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLFixedVertexProcessing_discard_getset }
,
    { (char *) "clipNegativeOneToOne", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the clip-space Z goes from ``-1`` to ``1``.\n"
		"\n"
		"``False`` if the clip-space Z goes from ``0`` to ``1``.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLFixedVertexProcessing_clipNegativeOneToOne_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__FixedVertexProcessing_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__FixedVertexProcessing_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__FixedVertexProcessing_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLFixedVertexProcessing",      /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLFixedVertexProcessing_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__FixedVertexProcessing_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__GLPipe__FixedVertexProcessing_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__FixedVertexProcessing_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__FixedVertexProcessing_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the setup for fixed vertex processing operations.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__FixedVertexProcessing_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__FixedVertexProcessing_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__FixedVertexProcessing_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLFixedVertexProcessing,                 /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__FixedVertexProcessing_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__FixedVertexProcessing_type};

static SwigPyGetSet GLTextureCompleteness___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLTextureCompleteness_descriptorByteOffset_getset = { _wrap_GLTextureCompleteness_descriptorByteOffset_get, _wrap_GLTextureCompleteness_descriptorByteOffset_set };
static SwigPyGetSet GLTextureCompleteness_typeConflict_getset = { _wrap_GLTextureCompleteness_typeConflict_get, _wrap_GLTextureCompleteness_typeConflict_set };
static SwigPyGetSet GLTextureCompleteness_completeStatus_getset = { _wrap_GLTextureCompleteness_completeStatus_get, _wrap_GLTextureCompleteness_completeStatus_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__TextureCompleteness_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::TextureCompleteness.__dict__", (void *) &GLTextureCompleteness___dict___getset }
,
    { (char *) "descriptorByteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset in the GL descriptor storage of the problematic descriptor\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GLTextureCompleteness_descriptorByteOffset_getset }
,
    { (char *) "typeConflict", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The details of any type conflict on this binding. This can happen if\n"
		"multiple uniforms are pointing to the same binding but with different types. In this case it is\n"
		"impossible to disambiguate which binding was used.\n"
		"\n"
		"If this string is empty, no conflict is present. Otherwise it contains the bindings which are\n"
		"in conflict and their types.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &GLTextureCompleteness_typeConflict_getset }
,
    { (char *) "completeStatus", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The details of the texture's (in)completeness. If this string is empty, the texture is\n"
		"complete. Otherwise it contains an explanation of why the texture is believed to be incomplete.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &GLTextureCompleteness_completeStatus_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__TextureCompleteness_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_GLTextureCompleteness___eq__(self, other); break;
    case Py_LT : result = _wrap_GLTextureCompleteness___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__TextureCompleteness_methods[] = {
  { "__eq__", (PyCFunction) _wrap_GLTextureCompleteness___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_GLTextureCompleteness___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__TextureCompleteness_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLTextureCompleteness",        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLTextureCompleteness_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__TextureCompleteness_type.as_number,   /* tp_as_number */
    &SwigPyBuiltin__GLPipe__TextureCompleteness_type.as_sequence, /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__TextureCompleteness_type.as_mapping,  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__TextureCompleteness_type.as_buffer,   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the a texture completeness issue of a descriptor.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__TextureCompleteness_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__TextureCompleteness_methods,           /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__TextureCompleteness_getset,            /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLTextureCompleteness,                   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__TextureCompleteness_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__TextureCompleteness_type};

static SwigPyGetSet GLFeedback_feedbackResourceId_getset = { _wrap_GLFeedback_feedbackResourceId_get, _wrap_GLFeedback_feedbackResourceId_set };
static SwigPyGetSet GLFeedback_bufferResourceId_getset = { _wrap_GLFeedback_bufferResourceId_get, _wrap_GLFeedback_bufferResourceId_set };
static SwigPyGetSet GLFeedback_active_getset = { _wrap_GLFeedback_active_get, _wrap_GLFeedback_active_set };
static SwigPyGetSet GLFeedback___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLFeedback_byteOffset_getset = { _wrap_GLFeedback_byteOffset_get, _wrap_GLFeedback_byteOffset_set };
static SwigPyGetSet GLFeedback_byteSize_getset = { _wrap_GLFeedback_byteSize_get, _wrap_GLFeedback_byteSize_set };
static SwigPyGetSet GLFeedback_paused_getset = { _wrap_GLFeedback_paused_get, _wrap_GLFeedback_paused_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__Feedback_getset[] = {
    { (char *) "feedbackResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the transform feedback binding.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &GLFeedback_feedbackResourceId_getset }
,
    { (char *) "bufferResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The buffer bindings.\n"
		"\n"
		":type: Tuple[ResourceId,ResourceId,ResourceId,ResourceId]\n"
		"\n"
		"", (void *) &GLFeedback_bufferResourceId_getset }
,
    { (char *) "active", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the transform feedback object is currently active.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLFeedback_active_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::Feedback.__dict__", (void *) &GLFeedback___dict___getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The buffer byte offsets.\n"
		"\n"
		":type: Tuple[int,int,int,int]\n"
		"\n"
		"", (void *) &GLFeedback_byteOffset_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The buffer byte sizes.\n"
		"\n"
		":type: Tuple[int,int,int,int]\n"
		"\n"
		"", (void *) &GLFeedback_byteSize_getset }
,
    { (char *) "paused", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the transform feedback object is currently paused.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLFeedback_paused_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__Feedback_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__Feedback_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__Feedback_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLFeedback",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLFeedback_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__Feedback_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__GLPipe__Feedback_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__Feedback_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__Feedback_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the current feedback state.",  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__Feedback_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__Feedback_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__Feedback_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLFeedback,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__Feedback_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__Feedback_type};

static SwigPyGetSet GLRasterizerState_depthBias_getset = { _wrap_GLRasterizerState_depthBias_get, _wrap_GLRasterizerState_depthBias_set };
static SwigPyGetSet GLRasterizerState_slopeScaledDepthBias_getset = { _wrap_GLRasterizerState_slopeScaledDepthBias_get, _wrap_GLRasterizerState_slopeScaledDepthBias_set };
static SwigPyGetSet GLRasterizerState_sampleShading_getset = { _wrap_GLRasterizerState_sampleShading_get, _wrap_GLRasterizerState_sampleShading_set };
static SwigPyGetSet GLRasterizerState_sampleCoverageInvert_getset = { _wrap_GLRasterizerState_sampleCoverageInvert_get, _wrap_GLRasterizerState_sampleCoverageInvert_set };
static SwigPyGetSet GLRasterizerState_programmablePointSize_getset = { _wrap_GLRasterizerState_programmablePointSize_get, _wrap_GLRasterizerState_programmablePointSize_set };
static SwigPyGetSet GLRasterizerState_pointSize_getset = { _wrap_GLRasterizerState_pointSize_get, _wrap_GLRasterizerState_pointSize_set };
static SwigPyGetSet GLRasterizerState_fillMode_getset = { _wrap_GLRasterizerState_fillMode_get, _wrap_GLRasterizerState_fillMode_set };
static SwigPyGetSet GLRasterizerState_cullMode_getset = { _wrap_GLRasterizerState_cullMode_get, _wrap_GLRasterizerState_cullMode_set };
static SwigPyGetSet GLRasterizerState_minSampleShadingRate_getset = { _wrap_GLRasterizerState_minSampleShadingRate_get, _wrap_GLRasterizerState_minSampleShadingRate_set };
static SwigPyGetSet GLRasterizerState_offsetClamp_getset = { _wrap_GLRasterizerState_offsetClamp_get, _wrap_GLRasterizerState_offsetClamp_set };
static SwigPyGetSet GLRasterizerState_sampleMaskValue_getset = { _wrap_GLRasterizerState_sampleMaskValue_get, _wrap_GLRasterizerState_sampleMaskValue_set };
static SwigPyGetSet GLRasterizerState_alphaToOne_getset = { _wrap_GLRasterizerState_alphaToOne_get, _wrap_GLRasterizerState_alphaToOne_set };
static SwigPyGetSet GLRasterizerState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLRasterizerState_frontCCW_getset = { _wrap_GLRasterizerState_frontCCW_get, _wrap_GLRasterizerState_frontCCW_set };
static SwigPyGetSet GLRasterizerState_sampleCoverageValue_getset = { _wrap_GLRasterizerState_sampleCoverageValue_get, _wrap_GLRasterizerState_sampleCoverageValue_set };
static SwigPyGetSet GLRasterizerState_pointOriginUpperLeft_getset = { _wrap_GLRasterizerState_pointOriginUpperLeft_get, _wrap_GLRasterizerState_pointOriginUpperLeft_set };
static SwigPyGetSet GLRasterizerState_depthClamp_getset = { _wrap_GLRasterizerState_depthClamp_get, _wrap_GLRasterizerState_depthClamp_set };
static SwigPyGetSet GLRasterizerState_multisampleEnable_getset = { _wrap_GLRasterizerState_multisampleEnable_get, _wrap_GLRasterizerState_multisampleEnable_set };
static SwigPyGetSet GLRasterizerState_sampleMask_getset = { _wrap_GLRasterizerState_sampleMask_get, _wrap_GLRasterizerState_sampleMask_set };
static SwigPyGetSet GLRasterizerState_sampleCoverage_getset = { _wrap_GLRasterizerState_sampleCoverage_get, _wrap_GLRasterizerState_sampleCoverage_set };
static SwigPyGetSet GLRasterizerState_alphaToCoverage_getset = { _wrap_GLRasterizerState_alphaToCoverage_get, _wrap_GLRasterizerState_alphaToCoverage_set };
static SwigPyGetSet GLRasterizerState_lineWidth_getset = { _wrap_GLRasterizerState_lineWidth_get, _wrap_GLRasterizerState_lineWidth_set };
static SwigPyGetSet GLRasterizerState_pointFadeThreshold_getset = { _wrap_GLRasterizerState_pointFadeThreshold_get, _wrap_GLRasterizerState_pointFadeThreshold_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__RasterizerState_getset[] = {
    { (char *) "depthBias", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed depth bias value to apply to z-values.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &GLRasterizerState_depthBias_getset }
,
    { (char *) "slopeScaledDepthBias", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The slope-scaled depth bias value to apply to z-values.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &GLRasterizerState_slopeScaledDepthBias_getset }
,
    { (char *) "sampleShading", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if rendering should happen at sample-rate frequency.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLRasterizerState_sampleShading_getset }
,
    { (char *) "sampleCoverageInvert", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the temporary sample coverage mask should be inverted.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLRasterizerState_sampleCoverageInvert_getset }
,
    { (char *) "programmablePointSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the point size can be programmably exported from a shader.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLRasterizerState_programmablePointSize_getset }
,
    { (char *) "pointSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed point size in pixels.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &GLRasterizerState_pointSize_getset }
,
    { (char *) "fillMode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The polygon :class:`FillMode`.\n"
		"\n"
		":type: FillMode\n"
		"\n"
		"", (void *) &GLRasterizerState_fillMode_getset }
,
    { (char *) "cullMode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The polygon :class:`CullMode`.\n"
		"\n"
		":type: CullMode\n"
		"\n"
		"", (void *) &GLRasterizerState_cullMode_getset }
,
    { (char *) "minSampleShadingRate", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The minimum sample shading rate.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &GLRasterizerState_minSampleShadingRate_getset }
,
    { (char *) "offsetClamp", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The clamp value for calculated depth bias from :data:`depthBias` and\n"
		":data:`slopeScaledDepthBias`\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &GLRasterizerState_offsetClamp_getset }
,
    { (char *) "sampleMaskValue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The sample mask value that should be masked against the generated coverage.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GLRasterizerState_sampleMaskValue_getset }
,
    { (char *) "alphaToOne", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if alpha-to-one should be used when blending to an MSAA target.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLRasterizerState_alphaToOne_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::RasterizerState.__dict__", (void *) &GLRasterizerState___dict___getset }
,
    { (char *) "frontCCW", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if counter-clockwise polygons are front-facing.\n"
		"``False`` if clockwise polygons are front-facing.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLRasterizerState_frontCCW_getset }
,
    { (char *) "sampleCoverageValue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The sample coverage value used if :data:`sampleCoverage` is ``True``.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &GLRasterizerState_sampleCoverageValue_getset }
,
    { (char *) "pointOriginUpperLeft", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the point sprite texture origin is upper-left. ``False`` if lower-left.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLRasterizerState_pointOriginUpperLeft_getset }
,
    { (char *) "depthClamp", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if pixels outside of the near and far depth planes should be clamped and\n"
		"to ``0.0`` to ``1.0`` and not clipped.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLRasterizerState_depthClamp_getset }
,
    { (char *) "multisampleEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if multisampling should be used during rendering.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLRasterizerState_multisampleEnable_getset }
,
    { (char *) "sampleMask", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the generated samples should be bitwise ``AND`` masked with\n"
		":data:`sampleMaskValue`.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLRasterizerState_sampleMask_getset }
,
    { (char *) "sampleCoverage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if a temporary mask using :data:`sampleCoverageValue` should be used to\n"
		"resolve the final output color.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLRasterizerState_sampleCoverage_getset }
,
    { (char *) "alphaToCoverage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if alpha-to-coverage should be used when blending to an MSAA target.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLRasterizerState_alphaToCoverage_getset }
,
    { (char *) "lineWidth", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed line width in pixels.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &GLRasterizerState_lineWidth_getset }
,
    { (char *) "pointFadeThreshold", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The threshold value at which points are clipped if they exceed this size.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &GLRasterizerState_pointFadeThreshold_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__RasterizerState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__RasterizerState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__RasterizerState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLRasterizerState",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLRasterizerState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__RasterizerState_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__GLPipe__RasterizerState_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__RasterizerState_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__RasterizerState_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the rasterizer state toggles.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__RasterizerState_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__RasterizerState_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__RasterizerState_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLRasterizerState,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__RasterizerState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__RasterizerState_type};

static SwigPyGetSet GLRasterizer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLRasterizer_scissors_getset = { _wrap_GLRasterizer_scissors_get, _wrap_GLRasterizer_scissors_set };
static SwigPyGetSet GLRasterizer_state_getset = { _wrap_GLRasterizer_state_get, _wrap_GLRasterizer_state_set };
static SwigPyGetSet GLRasterizer_viewports_getset = { _wrap_GLRasterizer_viewports_get, _wrap_GLRasterizer_viewports_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__Rasterizer_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::Rasterizer.__dict__", (void *) &GLRasterizer___dict___getset }
,
    { (char *) "scissors", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound scissor regions.\n"
		"\n"
		":type: List[Scissor]\n"
		"\n"
		"", (void *) &GLRasterizer_scissors_getset }
,
    { (char *) "state", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The details of the rasterization state.\n"
		"\n"
		":type: GLRasterizerState\n"
		"\n"
		"", (void *) &GLRasterizer_state_getset }
,
    { (char *) "viewports", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound viewports.\n"
		"\n"
		":type: List[Viewport]\n"
		"\n"
		"", (void *) &GLRasterizer_viewports_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__Rasterizer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__Rasterizer_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__Rasterizer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLRasterizer",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLRasterizer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__Rasterizer_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__GLPipe__Rasterizer_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__Rasterizer_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__Rasterizer_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the rasterization state of the OpenGL pipeline.",  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__Rasterizer_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__Rasterizer_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__Rasterizer_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLRasterizer,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__Rasterizer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__Rasterizer_type};

static SwigPyGetSet GLDepthState_depthFunction_getset = { _wrap_GLDepthState_depthFunction_get, _wrap_GLDepthState_depthFunction_set };
static SwigPyGetSet GLDepthState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLDepthState_nearBound_getset = { _wrap_GLDepthState_nearBound_get, _wrap_GLDepthState_nearBound_set };
static SwigPyGetSet GLDepthState_farBound_getset = { _wrap_GLDepthState_farBound_get, _wrap_GLDepthState_farBound_set };
static SwigPyGetSet GLDepthState_depthBounds_getset = { _wrap_GLDepthState_depthBounds_get, _wrap_GLDepthState_depthBounds_set };
static SwigPyGetSet GLDepthState_depthEnable_getset = { _wrap_GLDepthState_depthEnable_get, _wrap_GLDepthState_depthEnable_set };
static SwigPyGetSet GLDepthState_depthWrites_getset = { _wrap_GLDepthState_depthWrites_get, _wrap_GLDepthState_depthWrites_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__DepthState_getset[] = {
    { (char *) "depthFunction", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`CompareFunction` to use for testing depth values.\n"
		"\n"
		":type: CompareFunction\n"
		"\n"
		"", (void *) &GLDepthState_depthFunction_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::DepthState.__dict__", (void *) &GLDepthState___dict___getset }
,
    { (char *) "nearBound", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The near plane bounding value.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &GLDepthState_nearBound_getset }
,
    { (char *) "farBound", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The far plane bounding value.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &GLDepthState_farBound_getset }
,
    { (char *) "depthBounds", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth bounds tests should be applied.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLDepthState_depthBounds_getset }
,
    { (char *) "depthEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth testing should be performed.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLDepthState_depthEnable_getset }
,
    { (char *) "depthWrites", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth values should be written to the depth target.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLDepthState_depthWrites_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__DepthState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__DepthState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__DepthState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLDepthState",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLDepthState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__DepthState_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__GLPipe__DepthState_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__DepthState_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__DepthState_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the depth state.",             /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__DepthState_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__DepthState_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__DepthState_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLDepthState,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__DepthState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__DepthState_type};

static SwigPyGetSet GLStencilState_frontFace_getset = { _wrap_GLStencilState_frontFace_get, _wrap_GLStencilState_frontFace_set };
static SwigPyGetSet GLStencilState_backFace_getset = { _wrap_GLStencilState_backFace_get, _wrap_GLStencilState_backFace_set };
static SwigPyGetSet GLStencilState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLStencilState_stencilEnable_getset = { _wrap_GLStencilState_stencilEnable_get, _wrap_GLStencilState_stencilEnable_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__StencilState_getset[] = {
    { (char *) "frontFace", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stencil state for front-facing polygons.\n"
		"\n"
		":type: StencilFace\n"
		"\n"
		"", (void *) &GLStencilState_frontFace_getset }
,
    { (char *) "backFace", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stencil state for back-facing polygons.\n"
		"\n"
		":type: StencilFace\n"
		"\n"
		"", (void *) &GLStencilState_backFace_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::StencilState.__dict__", (void *) &GLStencilState___dict___getset }
,
    { (char *) "stencilEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if stencil operations should be performed.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLStencilState_stencilEnable_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__StencilState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__StencilState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__StencilState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLStencilState",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLStencilState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__StencilState_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__GLPipe__StencilState_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__StencilState_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__StencilState_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the stencil state.",           /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__StencilState_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__StencilState_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__StencilState_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLStencilState,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__StencilState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__StencilState_type};

static SwigPyGetSet GLFBO_colorAttachments_getset = { _wrap_GLFBO_colorAttachments_get, _wrap_GLFBO_colorAttachments_set };
static SwigPyGetSet GLFBO_readBuffer_getset = { _wrap_GLFBO_readBuffer_get, _wrap_GLFBO_readBuffer_set };
static SwigPyGetSet GLFBO_resourceId_getset = { _wrap_GLFBO_resourceId_get, _wrap_GLFBO_resourceId_set };
static SwigPyGetSet GLFBO_drawBuffers_getset = { _wrap_GLFBO_drawBuffers_get, _wrap_GLFBO_drawBuffers_set };
static SwigPyGetSet GLFBO___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLFBO_depthAttachment_getset = { _wrap_GLFBO_depthAttachment_get, _wrap_GLFBO_depthAttachment_set };
static SwigPyGetSet GLFBO_stencilAttachment_getset = { _wrap_GLFBO_stencilAttachment_get, _wrap_GLFBO_stencilAttachment_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__FBO_getset[] = {
    { (char *) "colorAttachments", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The framebuffer color attachments.\n"
		"\n"
		":type: List[Descriptor]\n"
		"\n"
		"", (void *) &GLFBO_colorAttachments_getset }
,
    { (char *) "readBuffer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The read buffer index in the :data:`colorAttachments` attachment list.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GLFBO_readBuffer_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the framebuffer.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &GLFBO_resourceId_getset }
,
    { (char *) "drawBuffers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The draw buffer indices into the :data:`colorAttachments` attachment list.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &GLFBO_drawBuffers_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::FBO.__dict__", (void *) &GLFBO___dict___getset }
,
    { (char *) "depthAttachment", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The framebuffer depth attachment.\n"
		"\n"
		":type: Descriptor\n"
		"\n"
		"", (void *) &GLFBO_depthAttachment_getset }
,
    { (char *) "stencilAttachment", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The framebuffer stencil attachment.\n"
		"\n"
		":type: Descriptor\n"
		"\n"
		"", (void *) &GLFBO_stencilAttachment_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__FBO_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__FBO_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__FBO_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLFBO",                        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLFBO_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__FBO_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__GLPipe__FBO_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__FBO_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__FBO_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the contents of a framebuffer object.",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__FBO_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__FBO_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__FBO_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLFBO,               /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__FBO_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__FBO_type};

static SwigPyGetSet GLBlendState_blends_getset = { _wrap_GLBlendState_blends_get, _wrap_GLBlendState_blends_set };
static SwigPyGetSet GLBlendState_blendFactor_getset = { _wrap_GLBlendState_blendFactor_get, _wrap_GLBlendState_blendFactor_set };
static SwigPyGetSet GLBlendState___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__BlendState_getset[] = {
    { (char *) "blends", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The blend operations for each target.\n"
		"\n"
		":type: List[ColorBlend]\n"
		"\n"
		"", (void *) &GLBlendState_blends_getset }
,
    { (char *) "blendFactor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The constant blend factor to use in blend equations.\n"
		"\n"
		":type: Tuple[float,float,float,float]\n"
		"\n"
		"", (void *) &GLBlendState_blendFactor_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::BlendState.__dict__", (void *) &GLBlendState___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__BlendState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__BlendState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__BlendState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLBlendState",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLBlendState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__BlendState_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__GLPipe__BlendState_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__BlendState_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__BlendState_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the blend pipeline state.",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__BlendState_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__BlendState_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__BlendState_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLBlendState,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__BlendState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__BlendState_type};

static SwigPyGetSet GLFrameBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLFrameBuffer_framebufferSRGB_getset = { _wrap_GLFrameBuffer_framebufferSRGB_get, _wrap_GLFrameBuffer_framebufferSRGB_set };
static SwigPyGetSet GLFrameBuffer_drawFBO_getset = { _wrap_GLFrameBuffer_drawFBO_get, _wrap_GLFrameBuffer_drawFBO_set };
static SwigPyGetSet GLFrameBuffer_dither_getset = { _wrap_GLFrameBuffer_dither_get, _wrap_GLFrameBuffer_dither_set };
static SwigPyGetSet GLFrameBuffer_blendState_getset = { _wrap_GLFrameBuffer_blendState_get, _wrap_GLFrameBuffer_blendState_set };
static SwigPyGetSet GLFrameBuffer_readFBO_getset = { _wrap_GLFrameBuffer_readFBO_get, _wrap_GLFrameBuffer_readFBO_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__FrameBuffer_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::FrameBuffer.__dict__", (void *) &GLFrameBuffer___dict___getset }
,
    { (char *) "framebufferSRGB", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if sRGB correction should be applied when writing to an sRGB-formatted texture.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLFrameBuffer_framebufferSRGB_getset }
,
    { (char *) "drawFBO", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The draw framebuffer.\n"
		"\n"
		":type: GLFBO\n"
		"\n"
		"", (void *) &GLFrameBuffer_drawFBO_getset }
,
    { (char *) "dither", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if dithering should be used when writing to color buffers.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLFrameBuffer_dither_getset }
,
    { (char *) "blendState", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The details of the blending state.\n"
		"\n"
		":type: GLBlendState\n"
		"\n"
		"", (void *) &GLFrameBuffer_blendState_getset }
,
    { (char *) "readFBO", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The read framebuffer.\n"
		"\n"
		":type: GLFBO\n"
		"\n"
		"", (void *) &GLFrameBuffer_readFBO_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__FrameBuffer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__FrameBuffer_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__FrameBuffer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLFrameBuffer",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLFrameBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__FrameBuffer_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__GLPipe__FrameBuffer_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__FrameBuffer_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__FrameBuffer_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the current state of the framebuffer stage of the pipeline.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__FrameBuffer_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__FrameBuffer_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__FrameBuffer_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLFrameBuffer,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__FrameBuffer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__FrameBuffer_type};

static SwigPyGetSet GLHints_lineSmoothingEnabled_getset = { _wrap_GLHints_lineSmoothingEnabled_get, _wrap_GLHints_lineSmoothingEnabled_set };
static SwigPyGetSet GLHints_polySmoothingEnabled_getset = { _wrap_GLHints_polySmoothingEnabled_get, _wrap_GLHints_polySmoothingEnabled_set };
static SwigPyGetSet GLHints_derivatives_getset = { _wrap_GLHints_derivatives_get, _wrap_GLHints_derivatives_set };
static SwigPyGetSet GLHints___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLHints_textureCompression_getset = { _wrap_GLHints_textureCompression_get, _wrap_GLHints_textureCompression_set };
static SwigPyGetSet GLHints_lineSmoothing_getset = { _wrap_GLHints_lineSmoothing_get, _wrap_GLHints_lineSmoothing_set };
static SwigPyGetSet GLHints_polySmoothing_getset = { _wrap_GLHints_polySmoothing_get, _wrap_GLHints_polySmoothing_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__Hints_getset[] = {
    { (char *) "lineSmoothingEnabled", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if line smoothing is enabled.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLHints_lineSmoothingEnabled_getset }
,
    { (char *) "polySmoothingEnabled", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if polygon smoothing is enabled.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &GLHints_polySmoothingEnabled_getset }
,
    { (char *) "derivatives", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A :class:`QualityHint` with the derivatives hint.\n"
		"\n"
		":type: QualityHint\n"
		"\n"
		"", (void *) &GLHints_derivatives_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::Hints.__dict__", (void *) &GLHints___dict___getset }
,
    { (char *) "textureCompression", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A :class:`QualityHint` with the texture compression hint.\n"
		"\n"
		":type: QualityHint\n"
		"\n"
		"", (void *) &GLHints_textureCompression_getset }
,
    { (char *) "lineSmoothing", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A :class:`QualityHint` with the line smoothing hint.\n"
		"\n"
		":type: QualityHint\n"
		"\n"
		"", (void *) &GLHints_lineSmoothing_getset }
,
    { (char *) "polySmoothing", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A :class:`QualityHint` with the polygon smoothing hint.\n"
		"\n"
		":type: QualityHint\n"
		"\n"
		"", (void *) &GLHints_polySmoothing_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__Hints_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__Hints_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__Hints_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLHints",                      /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLHints_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__Hints_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__GLPipe__Hints_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__Hints_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__Hints_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the current state of GL hints and smoothing.",     /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__Hints_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__Hints_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__Hints_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GLHints,             /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__Hints_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__Hints_type};

static SwigPyGetSet GLState_transformFeedback_getset = { _wrap_GLState_transformFeedback_get, _wrap_GLState_transformFeedback_set };
static SwigPyGetSet GLState_stencilState_getset = { _wrap_GLState_stencilState_get, _wrap_GLState_stencilState_set };
static SwigPyGetSet GLState_vertexInput_getset = { _wrap_GLState_vertexInput_get, _wrap_GLState_vertexInput_set };
static SwigPyGetSet GLState_framebuffer_getset = { _wrap_GLState_framebuffer_get, _wrap_GLState_framebuffer_set };
static SwigPyGetSet GLState_pipelineResourceId_getset = { _wrap_GLState_pipelineResourceId_get, _wrap_GLState_pipelineResourceId_set };
static SwigPyGetSet GLState_descriptorStore_getset = { _wrap_GLState_descriptorStore_get, _wrap_GLState_descriptorStore_set };
static SwigPyGetSet GLState_descriptorCount_getset = { _wrap_GLState_descriptorCount_get, _wrap_GLState_descriptorCount_set };
static SwigPyGetSet GLState_depthState_getset = { _wrap_GLState_depthState_get, _wrap_GLState_depthState_set };
static SwigPyGetSet GLState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet GLState_hints_getset = { _wrap_GLState_hints_get, _wrap_GLState_hints_set };
static SwigPyGetSet GLState_vertexProcessing_getset = { _wrap_GLState_vertexProcessing_get, _wrap_GLState_vertexProcessing_set };
static SwigPyGetSet GLState_geometryShader_getset = { _wrap_GLState_geometryShader_get, _wrap_GLState_geometryShader_set };
static SwigPyGetSet GLState_computeShader_getset = { _wrap_GLState_computeShader_get, _wrap_GLState_computeShader_set };
static SwigPyGetSet GLState_descriptorByteSize_getset = { _wrap_GLState_descriptorByteSize_get, _wrap_GLState_descriptorByteSize_set };
static SwigPyGetSet GLState_textureCompleteness_getset = { _wrap_GLState_textureCompleteness_get, _wrap_GLState_textureCompleteness_set };
static SwigPyGetSet GLState_rasterizer_getset = { _wrap_GLState_rasterizer_get, _wrap_GLState_rasterizer_set };
static SwigPyGetSet GLState_vertexShader_getset = { _wrap_GLState_vertexShader_get, _wrap_GLState_vertexShader_set };
static SwigPyGetSet GLState_tessControlShader_getset = { _wrap_GLState_tessControlShader_get, _wrap_GLState_tessControlShader_set };
static SwigPyGetSet GLState_tessEvalShader_getset = { _wrap_GLState_tessEvalShader_get, _wrap_GLState_tessEvalShader_set };
static SwigPyGetSet GLState_fragmentShader_getset = { _wrap_GLState_fragmentShader_get, _wrap_GLState_fragmentShader_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GLPipe__State_getset[] = {
    { (char *) "transformFeedback", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The transform feedback stage.\n"
		"\n"
		":type: GLFeedback\n"
		"\n"
		"", (void *) &GLState_transformFeedback_getset }
,
    { (char *) "stencilState", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stencil state.\n"
		"\n"
		":type: GLStencilState\n"
		"\n"
		"", (void *) &GLState_stencilState_getset }
,
    { (char *) "vertexInput", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex input stage.\n"
		"\n"
		":type: GLVertexInput\n"
		"\n"
		"", (void *) &GLState_vertexInput_getset }
,
    { (char *) "framebuffer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound framebuffer.\n"
		"\n"
		":type: GLFrameBuffer\n"
		"\n"
		"", (void *) &GLState_framebuffer_getset }
,
    { (char *) "pipelineResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the program pipeline (if active).\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &GLState_pipelineResourceId_getset }
,
    { (char *) "descriptorStore", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The virtual descriptor storage.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &GLState_descriptorStore_getset }
,
    { (char *) "descriptorCount", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of descriptors in the virtual descriptor storage.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GLState_descriptorCount_getset }
,
    { (char *) "depthState", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The depth state.\n"
		"\n"
		":type: GLDepthState\n"
		"\n"
		"", (void *) &GLState_depthState_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GLPipe::State.__dict__", (void *) &GLState___dict___getset }
,
    { (char *) "hints", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The hint state.\n"
		"\n"
		":type: GLHints\n"
		"\n"
		"", (void *) &GLState_hints_getset }
,
    { (char *) "vertexProcessing", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed-function vertex processing stage.\n"
		"\n"
		":type: GLFixedVertexProcessing\n"
		"\n"
		"", (void *) &GLState_vertexProcessing_getset }
,
    { (char *) "geometryShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The geometry shader stage.\n"
		"\n"
		":type: GLShader\n"
		"\n"
		"", (void *) &GLState_geometryShader_getset }
,
    { (char *) "computeShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The compute shader stage.\n"
		"\n"
		":type: GLShader\n"
		"\n"
		"", (void *) &GLState_computeShader_getset }
,
    { (char *) "descriptorByteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte size of a descriptor in the virtual descriptor storage.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &GLState_descriptorByteSize_getset }
,
    { (char *) "textureCompleteness", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Texture completeness issues of descriptors in the descriptor store.\n"
		"\n"
		":type: GLTextureCompleteness\n"
		"\n"
		"", (void *) &GLState_textureCompleteness_getset }
,
    { (char *) "rasterizer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The rasterization configuration.\n"
		"\n"
		":type: GLRasterizer\n"
		"\n"
		"", (void *) &GLState_rasterizer_getset }
,
    { (char *) "vertexShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex shader stage.\n"
		"\n"
		":type: GLShader\n"
		"\n"
		"", (void *) &GLState_vertexShader_getset }
,
    { (char *) "tessControlShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The tessellation control shader stage.\n"
		"\n"
		":type: GLShader\n"
		"\n"
		"", (void *) &GLState_tessControlShader_getset }
,
    { (char *) "tessEvalShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The tessellation evaluation shader stage.\n"
		"\n"
		":type: GLShader\n"
		"\n"
		"", (void *) &GLState_tessEvalShader_getset }
,
    { (char *) "fragmentShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fragment shader stage.\n"
		"\n"
		":type: GLShader\n"
		"\n"
		"", (void *) &GLState_fragmentShader_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GLPipe__State_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GLPipe__State_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GLPipe__State_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.GLState",                      /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GLState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GLPipe__State_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__GLPipe__State_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__GLPipe__State_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GLPipe__State_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The full current OpenGL pipeline state.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GLPipe__State_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GLPipe__State_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GLPipe__State_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GLPipe__State_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GLPipe__State_type};

static SwigPyGetSet SectionType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SectionType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SectionType.__dict__", (void *) &SectionType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SectionType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SectionType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SectionType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "SectionType",                            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_SectionType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SectionType_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__SectionType_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__SectionType_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SectionType_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The types of several pre-defined and known sections. This allows consumers of the API\n"
		"to recognise and understand the contents of the section.\n"
		"\n"
		"Note that sections above the highest value here may be encountered if they were written in a new\n"
		"version of RenderDoc that addes a new section type. They should be considered equal to\n"
		":data:`Unknown` by any processing.\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  An unknown section - any custom or non-predefined section will have this type.\n"
		"\n"
		".. data:: FrameCapture\n"
		"\n"
		"  This section contains the actual captured frame, in RenderDoc's internal chunked representation.\n"
		"  The contents can be fetched as structured data with or without replaying the frame.\n"
		"\n"
		"  The name for this section will be \"renderdoc/internal/framecapture\".\n"
		"\n"
		".. data:: ResolveDatabase\n"
		"\n"
		"  This section contains platform-specific data used to resolve callstacks.\n"
		"\n"
		"  The name for this section will be \"renderdoc/internal/resolvedb\".\n"
		"\n"
		".. data:: Bookmarks\n"
		"\n"
		"  This section contains a JSON document with bookmarks added to the capture to highlight important\n"
		"  events.\n"
		"\n"
		"  The name for this section will be \"renderdoc/ui/bookmarks\".\n"
		"\n"
		".. data:: Notes\n"
		"\n"
		"  This section contains a JSON document with free-form information added for human consumption, e.g.\n"
		"  details about how the capture was obtained with repro steps in the original program, or with\n"
		"  driver and machine info.\n"
		"\n"
		"  The name for this section will be \"renderdoc/ui/notes\".\n"
		"\n"
		".. data:: ResourceRenames\n"
		"\n"
		"  This section contains a JSON document with custom names applied to resources in the UI, over and\n"
		"  above any friendly names specified in the capture itself.\n"
		"\n"
		"  The name for this section will be \"renderdoc/ui/resrenames\".\n"
		"\n"
		".. data:: AMDRGPProfile\n"
		"\n"
		"  This section contains a .rgp profile from AMD's RGP tool, which can be extracted and loaded.\n"
		"\n"
		"  The name for this section will be \"amd/rgp/profile\".\n"
		"\n"
		".. data:: ExtendedThumbnail\n"
		"\n"
		"  This section contains a thumbnail in format other than JPEG. For example, when it needs to be\n"
		"  lossless.\n"
		"\n"
		"  The name for this section will be \"renderdoc/internal/exthumb\".\n"
		"\n"
		".. data:: EmbeddedLogfile\n"
		"\n"
		"  This section contains the log file at the time of capture, for debugging.\n"
		"\n"
		"  The name for this section will be \"renderdoc/internal/logfile\".\n"
		"\n"
		".. data:: EditedShaders\n"
		"\n"
		"  This section contains any edited shaders.\n"
		"\n"
		"  The name for this section will be \"renderdoc/ui/edits\".\n"
		"\n"
		".. data:: D3D12Core\n"
		"\n"
		"  This section contains an internal copy of D3D12Core for replaying.\n"
		"\n"
		"  The name for this section will be \"renderdoc/internal/d3d12core\".\n"
		"\n"
		".. data:: D3D12SDKLayers\n"
		"\n"
		"  This section contains an internal copy of D3D12SDKLayers for replaying.\n"
		"\n"
		"  The name for this section will be \"renderdoc/internal/d3d12sdklayers\".\n"
		"\n"
		".. data:: EmbeddedExternalFiles\n"
		"\n"
		"  This section contains externally referenced files that have been embedded into the capture.\n"
		"\n"
		"  The name for this section will be \"renderdoc/internal/embeddedexternalfiles\".\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SectionType_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SectionType_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SectionType_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_SectionType,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SectionType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SectionType_type};

static SwigPyGetSet DebugVariableType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DebugVariableType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DebugVariableType.__dict__", (void *) &DebugVariableType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DebugVariableType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DebugVariableType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DebugVariableType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "DebugVariableType",                      /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DebugVariableType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DebugVariableType_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__DebugVariableType_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__DebugVariableType_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DebugVariableType_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Represents the category of debugging variable that a source variable maps to.\n"
		"\n"
		".. data:: Undefined\n"
		"\n"
		"  Undefined type.\n"
		"\n"
		".. data:: Input\n"
		"\n"
		"  A constant input value, stored globally.\n"
		"\n"
		".. data:: Constant\n"
		"\n"
		"  A constant buffer value, stored globally.\n"
		"\n"
		".. data:: Sampler\n"
		"\n"
		"  A sampler, stored globally.\n"
		"\n"
		".. data:: ReadOnlyResource\n"
		"\n"
		"  A read-only resource, stored globally.\n"
		"\n"
		".. data:: ReadWriteResource\n"
		"\n"
		"  A read-write resource, stored globally.\n"
		"\n"
		".. data:: Variable\n"
		"\n"
		"  A mutable variable, stored per state.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DebugVariableType_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DebugVariableType_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DebugVariableType_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DebugVariableType,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DebugVariableType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DebugVariableType_type};

static SwigPyGetSet VarType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VarType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VarType.__dict__", (void *) &VarType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VarType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VarType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VarType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "VarType",                                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VarType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VarType_type.as_number,   /* tp_as_number */
    &SwigPyBuiltin__VarType_type.as_sequence, /* tp_as_sequence */
    &SwigPyBuiltin__VarType_type.as_mapping,  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VarType_type.as_buffer,   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Represents the base type of a shader variable in debugging or constant blocks.\n"
		"\n"
		".. data:: Float\n"
		"\n"
		"  A single-precision (32-bit) floating point value.\n"
		"\n"
		".. data:: Double\n"
		"\n"
		"  A double-precision (64-bit) floating point value.\n"
		"\n"
		".. data:: Half\n"
		"\n"
		"  A half-precision (16-bit) floating point value.\n"
		"\n"
		".. data:: SInt\n"
		"\n"
		"  A signed 32-bit integer value.\n"
		"\n"
		".. data:: UInt\n"
		"\n"
		"  An unsigned 32-bit integer value.\n"
		"\n"
		".. data:: SShort\n"
		"\n"
		"  A signed 16-bit integer value.\n"
		"\n"
		".. data:: UShort\n"
		"\n"
		"  An unsigned 16-bit integer value.\n"
		"\n"
		".. data:: SLong\n"
		"\n"
		"  A signed 64-bit integer value.\n"
		"\n"
		".. data:: ULong\n"
		"\n"
		"  An unsigned 64-bit integer value.\n"
		"\n"
		".. data:: SByte\n"
		"\n"
		"  A signed 8-bit integer value.\n"
		"\n"
		".. data:: UByte\n"
		"\n"
		"  An unsigned 8-bit integer value.\n"
		"\n"
		".. data:: Bool\n"
		"\n"
		"  A boolean value.\n"
		"\n"
		".. data:: Enum\n"
		"\n"
		"  An enum - each member gives a named value, and the type itself is stored as an integer.\n"
		"\n"
		".. data:: Struct\n"
		"\n"
		"  A structure with some number of members.\n"
		"\n"
		".. data:: GPUPointer\n"
		"\n"
		"  A 64-bit pointer into GPU-addressable memory. Variables with this type are stored with opaque\n"
		"  contents and should be decoded with :meth:`ShaderVariable.GetPointer`.\n"
		"\n"
		".. data:: ConstantBlock\n"
		"\n"
		"  A reference to a constant block bound to the shader. Variables with this type are stored with\n"
		"  opaque contents and should be decoded with :meth:`ShaderVariable.GetBinding`.\n"
		"\n"
		".. data:: ReadOnlyResource\n"
		"\n"
		"  A reference to a read only resource bound to the shader. Variables with this type are stored with\n"
		"  opaque contents and should be decoded with :meth:`ShaderVariable.GetBinding`.\n"
		"\n"
		".. data:: ReadWriteResource\n"
		"\n"
		"  A reference to a read/write resource bound to the shader. Variables with this type are stored with\n"
		"  opaque contents and should be decoded with :meth:`ShaderVariable.GetBinding`.\n"
		"\n"
		".. data:: Sampler\n"
		"\n"
		"  A reference to a sampler bound to the shader. Variables with this type are stored with opaque\n"
		"  contents and should be decoded with :meth:`ShaderVariable.GetBinding`.\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  An unknown type.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VarType_richcompare,             /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VarType_methods,           /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VarType_getset,            /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VarType,             /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VarType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VarType_type};

static SwigPyGetSet CompType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CompType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"CompType.__dict__", (void *) &CompType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__CompType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__CompType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__CompType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "CompType",                               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_CompType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__CompType_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__CompType_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__CompType_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__CompType_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Represents the component type of a channel in a texture or element in a structure.\n"
		"\n"
		".. data:: Typeless\n"
		"\n"
		"  A component that has no concrete type.\n"
		"\n"
		".. data:: Float\n"
		"\n"
		"  An IEEE floating point value of 64-bit, 32-bit or 16-bit size.\n"
		"\n"
		".. data:: UNorm\n"
		"\n"
		"  An unsigned normalised floating point value. This is converted by dividing the input value by\n"
		"  the maximum representable unsigned integer value, to produce a value in the range ``[0, 1]``\n"
		"\n"
		".. data:: SNorm\n"
		"\n"
		"  A signed normalised floating point value in range. This is converted by dividing the input value\n"
		"  by the maximum representable *positive signed* integer value, to produce a value in the range\n"
		"  ``[-1, 1]``. As a special case, the maximum negative signed integer is also mapped to ``-1`` so\n"
		"  there are two representations of -1. This means there is only one ``0`` value and that there is\n"
		"  the same range of available values for positive and negative values.\n"
		"\n"
		"  For example, signed 16-bit integers range from ``-32768`` to ``+32767``. ``-32768`` is mapped to\n"
		"  ``-1``, and then any other value is divided by ``32767`` giving an equal set of values in the\n"
		"  range ``[-1, 0]`` as in the range ``[0, 1]``.\n"
		"\n"
		".. data:: UInt\n"
		"\n"
		"  An unsigned integer value.\n"
		"\n"
		".. data:: SInt\n"
		"\n"
		"  A signed integer value.\n"
		"\n"
		".. data:: UScaled\n"
		"\n"
		"  An unsigned scaled floating point value. This is converted from the input unsigned integer without\n"
		"  any normalisation as with :data:`UNorm`, so the resulting values range from ``0`` to the maximum\n"
		"  unsigned integer value ``2^N - 1``.\n"
		"\n"
		".. data:: SScaled\n"
		"\n"
		"  A signed scaled floating point value. This is converted from the input signed integer without\n"
		"  any normalisation as with :data:`SNorm`, so the resulting values range from the minimum signed\n"
		"  integer value ``-2^(N-1)`` to the maximum signed integer value ``2^(N-1) - 1``.\n"
		"\n"
		".. data:: Depth\n"
		"\n"
		"  An opaque value storing depth information, either :data:`floating point <float>` for 32-bit depth\n"
		"  values or else :data:`unsigned normalised <UNorm>` for other bit sizes.\n"
		"\n"
		".. data:: UNormSRGB\n"
		"\n"
		"  Similar to :data:`UNorm` normalised between the minimum and maximum unsigned values to ``0.0`` -\n"
		"  ``1.0``, but with an sRGB gamma curve applied.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__CompType_richcompare,            /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__CompType_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__CompType_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_CompType,            /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__CompType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CompType_type};

static SwigPyGetSet TextureSwizzle___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TextureSwizzle_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TextureSwizzle.__dict__", (void *) &TextureSwizzle___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TextureSwizzle_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TextureSwizzle_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TextureSwizzle_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "TextureSwizzle",                         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TextureSwizzle_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TextureSwizzle_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__TextureSwizzle_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__TextureSwizzle_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TextureSwizzle_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A single source component for a destination texture swizzle.\n"
		"\n"
		".. data:: Red\n"
		"\n"
		"  The Red component.\n"
		"\n"
		".. data:: Green\n"
		"\n"
		"  The Green component.\n"
		"\n"
		".. data:: Blue\n"
		"\n"
		"  The Blue component.\n"
		"\n"
		".. data:: Alpha\n"
		"\n"
		"  The Alpha component.\n"
		"\n"
		".. data:: Zero\n"
		"\n"
		"  The fixed value ``0``.\n"
		"\n"
		".. data:: One\n"
		"\n"
		"  The fixed value ``1``.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TextureSwizzle_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TextureSwizzle_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TextureSwizzle_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TextureSwizzle,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TextureSwizzle_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TextureSwizzle_type};

static SwigPyGetSet AddressMode___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__AddressMode_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"AddressMode.__dict__", (void *) &AddressMode___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__AddressMode_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__AddressMode_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__AddressMode_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "AddressMode",                            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_AddressMode_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__AddressMode_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__AddressMode_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__AddressMode_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__AddressMode_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A texture addressing mode in a single direction (U,V or W).\n"
		"\n"
		".. data:: Wrap\n"
		"\n"
		"  The texture is tiled at every multiple of 1.0.\n"
		"\n"
		".. data:: Repeat\n"
		"\n"
		"  Alias of :data:`Wrap`.\n"
		"\n"
		".. data:: Mirror\n"
		"\n"
		"  The texture is tiled as with :data:`Wrap`, but with the absolute value of the texture co-ordinate.\n"
		"\n"
		".. data:: MirrorRepeat\n"
		"\n"
		"  Alias of :data:`Mirror`.\n"
		"\n"
		".. data:: MirrorOnce\n"
		"\n"
		"  The texture is mirrored with :data:`Mirror`, but the texture does not tile as with\n"
		"  :data:`ClampEdge`.\n"
		"\n"
		".. data:: MirrorClamp\n"
		"\n"
		"  Alias of :data:`MirrorOnce`.\n"
		"\n"
		".. data:: ClampEdge\n"
		"\n"
		"  The texture is clamped to the range of ``[0.0, 1.0]`` and the texture value at each end used.\n"
		"\n"
		".. data:: ClampBorder\n"
		"\n"
		"  The texture is clamped such that texture co-ordinates outside the range of ``[0.0, 1.0]`` are set\n"
		"  to the border color specified in the sampler.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__AddressMode_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__AddressMode_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__AddressMode_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_AddressMode,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__AddressMode_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__AddressMode_type};

static SwigPyGetSet YcbcrConversion___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__YcbcrConversion_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"YcbcrConversion.__dict__", (void *) &YcbcrConversion___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__YcbcrConversion_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__YcbcrConversion_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__YcbcrConversion_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "YcbcrConversion",                        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_YcbcrConversion_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__YcbcrConversion_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__YcbcrConversion_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__YcbcrConversion_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__YcbcrConversion_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The color model conversion that a YCbCr sampler uses to convert from YCbCr to RGB.\n"
		"\n"
		".. data:: Raw\n"
		"\n"
		"  The input values are not converted at all.\n"
		"\n"
		".. data:: RangeOnly\n"
		"\n"
		"  There is no model conversion but the inputs are range expanded as for YCbCr.\n"
		"\n"
		".. data:: BT709\n"
		"\n"
		"  The conversion uses the BT.709 color model conversion.\n"
		"\n"
		".. data:: BT601\n"
		"\n"
		"  The conversion uses the BT.601 color model conversion.\n"
		"\n"
		".. data:: BT2020\n"
		"\n"
		"  The conversion uses the BT.2020 color model conversion.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__YcbcrConversion_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__YcbcrConversion_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__YcbcrConversion_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_YcbcrConversion,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__YcbcrConversion_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__YcbcrConversion_type};

static SwigPyGetSet YcbcrRange___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__YcbcrRange_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"YcbcrRange.__dict__", (void *) &YcbcrRange___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__YcbcrRange_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__YcbcrRange_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__YcbcrRange_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "YcbcrRange",                             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_YcbcrRange_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__YcbcrRange_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__YcbcrRange_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__YcbcrRange_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__YcbcrRange_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Specifies the range of encoded values and their interpretation.\n"
		"\n"
		".. data:: ITUFull\n"
		"\n"
		"  The full range of input values are valid and interpreted according to ITU \"full range\" rules.\n"
		"\n"
		".. data:: ITUNarrow\n"
		"\n"
		"  A head and foot are reserved in the encoded values, and the remaining values are expanded\n"
		"  according to \"narrow range\" rules.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__YcbcrRange_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__YcbcrRange_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__YcbcrRange_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_YcbcrRange,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__YcbcrRange_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__YcbcrRange_type};

static SwigPyGetSet ChromaSampleLocation___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ChromaSampleLocation_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ChromaSampleLocation.__dict__", (void *) &ChromaSampleLocation___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ChromaSampleLocation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ChromaSampleLocation_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ChromaSampleLocation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ChromaSampleLocation",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ChromaSampleLocation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ChromaSampleLocation_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__ChromaSampleLocation_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__ChromaSampleLocation_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ChromaSampleLocation_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Determines where in the pixel downsampled chrome samples are positioned.\n"
		"\n"
		".. data:: CositedEven\n"
		"\n"
		"  The chroma samples are positioned exactly in the same place as the even luma co-ordinates.\n"
		"\n"
		".. data:: Midpoint\n"
		"\n"
		"  The chrome samples are positioned half way between each even luma sample and the next highest odd\n"
		"  luma sample.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ChromaSampleLocation_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ChromaSampleLocation_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ChromaSampleLocation_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ChromaSampleLocation,/* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ChromaSampleLocation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ChromaSampleLocation_type};

static SwigPyGetSet ResourceType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ResourceType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ResourceType.__dict__", (void *) &ResourceType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ResourceType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ResourceType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ResourceType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ResourceType",                           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ResourceType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ResourceType_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__ResourceType_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__ResourceType_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ResourceType_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The type of a resource referred to by binding or API usage.\n"
		"\n"
		"In some cases there is a little overlap or fudging when mapping API concepts - this is primarily\n"
		"just intended for e.g. fuzzy user filtering or rough categorisation. Precise mapping would require\n"
		"API-specific concepts.\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  An unknown type of resource.\n"
		"\n"
		".. data:: Device\n"
		"\n"
		"  A system-level object, typically unique.\n"
		"\n"
		".. data:: Queue\n"
		"\n"
		"  A queue representing the ability to execute commands in a single stream, possibly in parallel to\n"
		"  other queues.\n"
		"\n"
		".. data:: CommandBuffer\n"
		"\n"
		"  A recorded set of commands that can then be subsequently executed.\n"
		"\n"
		".. data:: Texture\n"
		"\n"
		"  A texture - one- to three- dimensional, possibly with array layers and mip levels. See\n"
		"  :class:`TextureDescription`.\n"
		"\n"
		".. data:: Buffer\n"
		"\n"
		"  A linear (possibly typed) view of memory. See :class:`BufferDescription`.\n"
		"\n"
		".. data:: View\n"
		"\n"
		"  A particular view into a texture or buffer, e.g. either accessing the underlying resource through\n"
		"  a different type, or only a subset of the resource.\n"
		"\n"
		".. data:: Sampler\n"
		"\n"
		"  The information regarding how a texture is accessed including wrapping, minification/magnification\n"
		"  and other information. The precise details are API-specific and listed in the API state when\n"
		"  bound.\n"
		"\n"
		".. data:: SwapchainImage\n"
		"\n"
		"  A special class of :data:`Texture` that is owned by the swapchain and is used for presentation.\n"
		"\n"
		".. data:: Memory\n"
		"\n"
		"  An object corresponding to an actual memory allocation, which other resources can then be bound\n"
		"  to.\n"
		"\n"
		".. data:: Shader\n"
		"\n"
		"  A single shader object for any shader stage. May be bound directly, or used to compose into a\n"
		"  :data:`PipelineState` depending on the API.\n"
		"\n"
		".. data:: ShaderBinding\n"
		"\n"
		"  An object that determines some manner of shader binding. Since this varies significantly by API,\n"
		"  different concepts used for shader resource binding fall under this type.\n"
		"\n"
		".. data:: PipelineState\n"
		"\n"
		"  A single object containing all information regarding the current GPU pipeline, containing both\n"
		"  shader objects, potentially some shader binding information, and fixed-function state.\n"
		"\n"
		".. data:: StateObject\n"
		"\n"
		"  A single object encapsulating some amount of related state that can be set together, instead of\n"
		"  setting each individual state separately.\n"
		"\n"
		".. data:: RenderPass\n"
		"\n"
		"  An object related to collecting render pass information together. This may not be an actual\n"
		"  explicit render pass object if it doesn't exist in the API, it may also be a collection of\n"
		"  textures in a framebuffer that are bound together to the API for rendering.\n"
		"\n"
		".. data:: Query\n"
		"\n"
		"  A query for retrieving some kind of feedback from the GPU, either as a fixed number or a boolean\n"
		"  value which can be used in predicated rendering.\n"
		"\n"
		".. data:: Sync\n"
		"\n"
		"  A synchronisation object used for either synchronisation between GPU and CPU, or GPU-to-GPU work.\n"
		"\n"
		".. data:: Pool\n"
		"\n"
		"  An object which pools together other objects in an opaque way, either for runtime allocation and\n"
		"  deallocation, or for caching purposes.\n"
		"\n"
		".. data:: AccelerationStructure\n"
		"\n"
		"  A structure used to carry implementation-defined spatial partitioning data and related\n"
		"  information, used to accelerate geometry intersection queries (e.g. for ray tracing).\n"
		"\n"
		".. data:: DescriptorStore\n"
		"\n"
		"  A descriptor store, either driver or application managed. For example a Vulkan descriptor set or\n"
		"  a D3D12 descriptor heap.\n"
		"\n"
		"  APIs without an explicit concept of descriptor storage will have virtual objects corresponding to\n"
		"  temporary bindings.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ResourceType_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ResourceType_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ResourceType_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ResourceType,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ResourceType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ResourceType_type};

static SwigPyGetSet TextureType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TextureType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TextureType.__dict__", (void *) &TextureType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TextureType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TextureType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TextureType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "TextureType",                            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TextureType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TextureType_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__TextureType_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__TextureType_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TextureType_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The dimensionality of a texture binding.\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  An unknown type of texture.\n"
		"\n"
		".. data:: Buffer\n"
		"\n"
		"  A texel buffer.\n"
		"\n"
		".. data:: Texture1D\n"
		"\n"
		"  A 1D texture.\n"
		"\n"
		".. data:: Texture1DArray\n"
		"\n"
		"  A 1D texture array.\n"
		"\n"
		".. data:: Texture2D\n"
		"\n"
		"  A 2D texture.\n"
		"\n"
		".. data:: TextureRect\n"
		"\n"
		"  A rectangle texture, a legacy format for non-power of two textures.\n"
		"\n"
		".. data:: Texture2DArray\n"
		"\n"
		"  A 2D texture array.\n"
		"\n"
		".. data:: Texture2DMS\n"
		"\n"
		"  A multi-sampled 2D texture.\n"
		"\n"
		".. data:: Texture2DMSArray\n"
		"\n"
		"  A multi-sampled 2D texture array.\n"
		"\n"
		".. data:: Texture3D\n"
		"\n"
		"  A 3D texture.\n"
		"\n"
		".. data:: TextureCube\n"
		"\n"
		"  A Cubemap texture.\n"
		"\n"
		".. data:: TextureCubeArray\n"
		"\n"
		"  A Cubemap texture array.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TextureType_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TextureType_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TextureType_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TextureType,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TextureType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TextureType_type};

static SwigPyGetSet BindType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__BindType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"BindType.__dict__", (void *) &BindType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__BindType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__BindType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__BindType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "BindType",                               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_BindType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__BindType_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__BindType_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__BindType_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__BindType_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The type of a shader resource bind.\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  An unknown type of binding.\n"
		"\n"
		".. data:: ConstantBuffer\n"
		"\n"
		"  A constant or uniform buffer.\n"
		"\n"
		".. data:: Sampler\n"
		"\n"
		"  A separate sampler object.\n"
		"\n"
		".. data:: ImageSampler\n"
		"\n"
		"  A combined image and sampler object.\n"
		"\n"
		".. data:: ReadOnlyImage\n"
		"\n"
		"  An image that can only be sampled from.\n"
		"\n"
		".. data:: ReadWriteImage\n"
		"\n"
		"  An image that can be read from and written to arbitrarily.\n"
		"\n"
		".. data:: ReadOnlyTBuffer\n"
		"\n"
		"  A texture buffer that can only be read from.\n"
		"\n"
		".. data:: ReadWriteTBuffer\n"
		"\n"
		"  A texture buffer that can be read from and written to arbitrarily.\n"
		"\n"
		".. data:: ReadOnlyBuffer\n"
		"\n"
		"  A buffer that can only be read from, distinct from :data:`ConstantBuffer`.\n"
		"\n"
		".. data:: ReadWriteBuffer\n"
		"\n"
		"  A buffer that can be read from and written to arbitrarily.\n"
		"\n"
		".. data:: ReadOnlyResource\n"
		"\n"
		"  A resource that can only be read from\n"
		"\n"
		".. data:: ReadWriteResource\n"
		"\n"
		"  A resource that can be read from and written to arbitrarily.\n"
		"\n"
		".. data:: InputAttachment\n"
		"\n"
		"  An input attachment for reading from the target currently being written.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__BindType_richcompare,            /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__BindType_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__BindType_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_BindType,            /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__BindType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__BindType_type};

static SwigPyGetSet DescriptorType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DescriptorType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DescriptorType.__dict__", (void *) &DescriptorType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DescriptorType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DescriptorType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DescriptorType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "DescriptorType",                         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DescriptorType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DescriptorType_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__DescriptorType_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__DescriptorType_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DescriptorType_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The type of a descriptor.\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  An unknown or uninitialised type of descriptor.\n"
		"\n"
		".. data:: ConstantBuffer\n"
		"\n"
		"  A constant or uniform buffer.\n"
		"\n"
		".. data:: Sampler\n"
		"\n"
		"  A separate sampler object.\n"
		"\n"
		".. data:: ImageSampler\n"
		"\n"
		"  A combined image and sampler object.\n"
		"\n"
		".. data:: Image\n"
		"\n"
		"  An image that can only be sampled from.\n"
		"\n"
		".. data:: Buffer\n"
		"\n"
		"  A buffer that can only be read from, with data read literally in a shader via raw or structured\n"
		"  access.\n"
		"\n"
		".. data:: TypedBuffer\n"
		"\n"
		"  A typed buffer that can only be read from, interpreting each element via a format decode.\n"
		"\n"
		".. data:: ReadWriteImage\n"
		"\n"
		"  An image that can be read from and written to arbitrarily.\n"
		"\n"
		".. data:: ReadWriteTypedBuffer\n"
		"\n"
		"  A typed/texture buffer that can be read from and written to arbitrarily.\n"
		"\n"
		".. data:: ReadWriteBuffer\n"
		"\n"
		"  A buffer that can be read from and written to arbitrarily.\n"
		"\n"
		".. data:: AccelerationStructure\n"
		"\n"
		"  A ray-tracing acceleration structure, read-only in the shader.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DescriptorType_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DescriptorType_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DescriptorType_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DescriptorType,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DescriptorType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DescriptorType_type};

static SwigPyGetSet DescriptorCategory___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DescriptorCategory_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DescriptorCategory.__dict__", (void *) &DescriptorCategory___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DescriptorCategory_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DescriptorCategory_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DescriptorCategory_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "DescriptorCategory",                     /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DescriptorCategory_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DescriptorCategory_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__DescriptorCategory_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__DescriptorCategory_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DescriptorCategory_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The category of a descriptor, corresponding to the interfaces in :class:`ShaderReflection`.\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  An unknown or uninitialised type of descriptor.\n"
		"\n"
		".. data:: ConstantBlock\n"
		"\n"
		"  A constant block.\n"
		"\n"
		".. data:: Sampler\n"
		"\n"
		"  A sampler object.\n"
		"\n"
		".. data:: ReadOnlyResource\n"
		"\n"
		"  A read-only resource.\n"
		"\n"
		".. data:: ReadWriteResource\n"
		"\n"
		"  A read-write resource.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DescriptorCategory_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DescriptorCategory_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DescriptorCategory_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DescriptorCategory,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DescriptorCategory_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DescriptorCategory_type};

static SwigPyGetSet ShaderBuiltin___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderBuiltin_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderBuiltin.__dict__", (void *) &ShaderBuiltin___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderBuiltin_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderBuiltin_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderBuiltin_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ShaderBuiltin",                          /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderBuiltin_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderBuiltin_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__ShaderBuiltin_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__ShaderBuiltin_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderBuiltin_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Annotates a particular built-in input or output from a shader with a special meaning to\n"
		"the hardware or API.\n"
		"\n"
		"Some of the built-in inputs or outputs can be declared multiple times in arrays or otherwise indexed\n"
		"to apply to multiple related things - see :data:`ClipDistance`, :data:`CullDistance` and\n"
		":data:`ColorOutput`.\n"
		"\n"
		".. data:: Undefined\n"
		"\n"
		"  Undefined built-in or no built-in is attached to this shader variable.\n"
		"\n"
		".. data:: Position\n"
		"\n"
		"  As an output from the final vertex processing shader stage, this feeds the vertex position to the\n"
		"  rasterized. As an input to the pixel shader stage this receives the position from the rasterizer.\n"
		"\n"
		".. data:: PointSize\n"
		"\n"
		"  An output that controls the size of point primitives.\n"
		"\n"
		".. data:: ClipDistance\n"
		"\n"
		"  An output for the distance to a user-defined clipping plane. Any pixel with an interpolated value\n"
		"  that is negative will not be rasterized. Typically there can be more than one such output.\n"
		"\n"
		".. data:: CullDistance\n"
		"\n"
		"  An output for the distance to a user-defined culling plane. Any primitive with all vertices having\n"
		"  negative values will not be rasterized. Typically there can be more than one such output.\n"
		"\n"
		".. data:: RTIndex\n"
		"\n"
		"  An output for selecting the render target index in an array to render to. Available in geometry\n"
		"  shaders and possibly earlier stages depending on hardware/API capability.\n"
		"\n"
		".. data:: ViewportIndex\n"
		"\n"
		"  An output for selecting the viewport index to render to. Available in geometry shaders and\n"
		"  possibly earlier stages depending on hardware/API capability.\n"
		"\n"
		".. data:: VertexIndex\n"
		"\n"
		"  An input to the vertex shader listing the vertex index. The exact meaning of this index can vary\n"
		"  by API but generally it refers to either a 0-based counter for non-indexed draws, or the index\n"
		"  value for indexed draws. It may or may not be affected by offsets, depending on API semantics.\n"
		"\n"
		".. data:: PrimitiveIndex\n"
		"\n"
		"  A built-in indicating which primitive is being processed. This can be read by all primitive stages\n"
		"  after the vertex shader, and written by the geometry shader.\n"
		"\n"
		".. data:: InstanceIndex\n"
		"\n"
		"  This built-in is defined similar to :data:`VertexIndex` but for instances within an instanced\n"
		"  drawcall. It counts from 0 and as with :data:`VertexIndex` it may or may not be affected by\n"
		"  drawcall offsets.\n"
		"\n"
		".. data:: DispatchSize\n"
		"\n"
		"  An input in compute shaders that gives the number of workgroups executed by the dispatch call.\n"
		"\n"
		".. data:: DispatchThreadIndex\n"
		"\n"
		"  An input in compute shaders giving a 3D shared index across all workgroups, such that the index\n"
		"  varies across each thread in the workgroup up to its size, then the indices for workgroup\n"
		"  ``(0,0,1)`` begin adjacent to where workgroup ``(0,0,0)`` ended.\n"
		"\n"
		"  This is related to :data:`GroupThreadIndex` and :data:`GroupIndex`.\n"
		"\n"
		".. data:: GroupIndex\n"
		"\n"
		"  An input in compute shaders giving a 3D index of this current workgroup amongst all workgroups,\n"
		"  up to the dispatch size.\n"
		"\n"
		"  The index is constant across all threads in the workgroup.\n"
		"\n"
		"  This is related to :data:`GroupThreadIndex` and :data:`DispatchThreadIndex`.\n"
		"\n"
		".. data:: GroupSize\n"
		"\n"
		"  The size of a workgroup, giving the number of threads in each dimension.\n"
		"\n"
		".. data:: GroupFlatIndex\n"
		"\n"
		"  An input in compute shaders giving a flat 1D index of the thread within the current workgroup.\n"
		"  This index increments first in the ``X`` dimension, then in the ``Y`` dimension, then in the ``Z``\n"
		"  dimension.\n"
		"\n"
		".. data:: GroupThreadIndex\n"
		"\n"
		"  An input in compute shaders giving a 3D index of this thread within its workgroup, up to the\n"
		"  workgroup size.\n"
		"\n"
		"  The input does not vary between one thread in a workgroup and the same thread in another\n"
		"  workgroup.\n"
		"\n"
		"  This is related to :data:`GroupIndex` and :data:`DispatchThreadIndex`.\n"
		"\n"
		"\n"
		".. data:: GSInstanceIndex\n"
		"\n"
		"  An input to the geometry shader giving the instance being run, if the geometry shader was setup to\n"
		"  be invoked multiple times for each input primitive.\n"
		"\n"
		".. data:: OutputControlPointIndex\n"
		"\n"
		"  An input to the tessellation control or hull shader giving the output control point index or patch\n"
		"  vertex being operated on.\n"
		"\n"
		".. data:: DomainLocation\n"
		"\n"
		"  An input to the tessellation evaluation or domain shader, giving the normalised location on the\n"
		"  output patch where evaluation is occuring. E.g. for triangle output this is the barycentric\n"
		"  co-ordinates of the output vertex.\n"
		"\n"
		".. data:: IsFrontFace\n"
		"\n"
		"  An input to the pixel shader indicating whether or not the contributing triangle was considered\n"
		"  front-facing or not according to the API setup for winding order and backface orientation.\n"
		"\n"
		".. data:: MSAACoverage\n"
		"\n"
		"  An input or an output from the pixel shader. As an input, it specifies a bitmask of which samples\n"
		"  in a pixel were covered by the rasterizer. As an output, it specifies which samples in the\n"
		"  destination target should be updated.\n"
		"\n"
		".. data:: MSAASamplePosition\n"
		"\n"
		"  An input to the pixel shader that contains the location of the current sample relative to the\n"
		"  pixel, when running the pixel shader at sample frequency.\n"
		"\n"
		".. data:: MSAASampleIndex\n"
		"\n"
		"  An input to the pixel shader that indicates which sample in the range ``0 .. N-1`` is currently\n"
		"  being processed.\n"
		"\n"
		".. data:: PatchNumVertices\n"
		"\n"
		"  An input to the tessellation stages, this gives the number of vertices in each patch.\n"
		"\n"
		".. data:: OuterTessFactor\n"
		"\n"
		"  An output from the tessellation control or hull shader, this determines the level to which the\n"
		"  outer edge of each primitive is tessellated by the fixed-function tessellator.\n"
		"\n"
		"  It is also available for reading in the tessellation evaluation or domain shader.\n"
		"\n"
		".. data:: InsideTessFactor\n"
		"\n"
		"  Related to :data:`OuterTessFactor` this functions in the same way to determine the tessellation\n"
		"  level inside the primitive.\n"
		"\n"
		".. data:: ColorOutput\n"
		"\n"
		"  An output from the pixel shader, this determines the color value written to the corresponding\n"
		"  target. There will be as many color output built-ins as there are targets bound.\n"
		"\n"
		".. data:: DepthOutput\n"
		"\n"
		"  An output from the pixel shader, writes the depth of this pixel with no restrictions.\n"
		"\n"
		"  Related to :data:`DepthOutputGreaterEqual` and :data:`DepthOutputLessEqual`.\n"
		"\n"
		".. data:: DepthOutputGreaterEqual\n"
		"\n"
		"  An output from the pixel shader, writes the depth of this pixel with the restriction that it will\n"
		"  be greater than or equal to the original depth produced by the rasterizer.\n"
		"\n"
		"  Related to :data:`DepthOutput` and :data:`DepthOutputLessEqual`.\n"
		"\n"
		".. data:: DepthOutputLessEqual\n"
		"\n"
		"  An output from the pixel shader, writes the depth of this pixel with the restriction that it will\n"
		"  be less than or equal to the original depth produced by the rasterizer.\n"
		"\n"
		"  Related to :data:`DepthOutputGreaterEqual` and :data:`DepthOutput`.\n"
		"\n"
		".. data:: BaseVertex\n"
		"\n"
		"  The first vertex processed in this draw, as specified by the ``firstVertex`` / ``baseVertex``\n"
		"  parameter to the draw call.\n"
		"\n"
		".. data:: BaseInstance\n"
		"\n"
		"  The first instance processed in this draw call, as specified by the ``firstInstance`` parameter.\n"
		"\n"
		".. data:: DrawIndex\n"
		"\n"
		"  For indirect or multi-draw commands, the index of this draw call within the overall draw command.\n"
		"\n"
		".. data:: StencilReference\n"
		"\n"
		"  The stencil reference to be used for stenciling operations on this fragment.\n"
		"\n"
		".. data:: PointCoord\n"
		"\n"
		"  The fragments co-ordinates within a point primitive being rasterized.\n"
		"\n"
		".. data:: IsHelper\n"
		"\n"
		"  Indicates if the current invocation is a helper invocation.\n"
		"\n"
		"\n"
		".. data:: SubgroupSize\n"
		"\n"
		"  The number of invocations in a subgroup.\n"
		"\n"
		".. data:: NumSubgroups\n"
		"\n"
		"  The number of subgroups in the local workgroup.\n"
		"\n"
		".. data:: SubgroupIndexInWorkgroup\n"
		"\n"
		"  The index of the current subgroup within all subgroups in the workgroup, up to\n"
		"  :data:`NumSubgroups` - 1.\n"
		"\n"
		".. data:: IndexInSubgroup\n"
		"\n"
		"  The index of the current thread in the current subgroup, up to :data:`SubgroupSize` - 1.\n"
		"\n"
		".. data:: SubgroupEqualMask\n"
		"\n"
		"  A bitmask where the bit corresponding to :data:`IndexInSubgroup` is set.\n"
		"\n"
		".. data:: SubgroupGreaterEqualMask\n"
		"\n"
		"  A bitmask where all bits greater or equal to the one corresponding to :data:`IndexInSubgroup` are\n"
		"  set.\n"
		"\n"
		".. data:: SubgroupGreaterMask\n"
		"\n"
		"  A bitmask where all bits greater than the one corresponding to :data:`IndexInSubgroup` are set.\n"
		"\n"
		".. data:: SubgroupLessEqualMask\n"
		"\n"
		"  A bitmask where all bits less or equal to the one corresponding to :data:`IndexInSubgroup` are\n"
		"  set.\n"
		"\n"
		".. data:: SubgroupLessMask\n"
		"\n"
		"  A bitmask where all bits less than the one corresponding to :data:`IndexInSubgroup` are set.\n"
		"\n"
		".. data:: DeviceIndex\n"
		"\n"
		"  The device index executing the shader, relative to the current device group.\n"
		"\n"
		".. data:: IsFullyCovered\n"
		"\n"
		"  Indicates if the current fragment area is fully covered by the generating primitive.\n"
		"\n"
		".. data:: FragAreaSize\n"
		"\n"
		"  Gives the dimensions of the area that the fragment covers.\n"
		"\n"
		".. data:: FragInvocationCount\n"
		"\n"
		"  Gives the maximum number of invocations for the fragment being covered.\n"
		"\n"
		".. data:: PackedFragRate\n"
		"\n"
		"  Contains the packed shading rate, with an API specific packing of X and Y. For example:\n"
		"\n"
		"  1x being 0, 2x being 1, 4x being 2. Then the lower two bits being the Y rate and the next 2 bits\n"
		"  being the X rate.\n"
		"\n"
		".. data:: Barycentrics\n"
		"\n"
		"  Contains the barycentric co-ordinates.\n"
		"\n"
		".. data:: CullPrimitive\n"
		"\n"
		"  An output to indicate whether or not a primitive should be culled.\n"
		"\n"
		".. data:: OutputIndices\n"
		"\n"
		"  An output containing the indices for a meshlet.\n"
		"\n"
		".. data:: MultiViewIndex\n"
		"\n"
		"  An input specifying the view being rendered to in multiview rendering. Only valid when multiview rendering is enabled.\n"
		"\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderBuiltin_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderBuiltin_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderBuiltin_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderBuiltin,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderBuiltin_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderBuiltin_type};

static SwigPyGetSet ReplayOutputType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ReplayOutputType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ReplayOutputType.__dict__", (void *) &ReplayOutputType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ReplayOutputType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ReplayOutputType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ReplayOutputType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ReplayOutputType",                       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ReplayOutputType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ReplayOutputType_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__ReplayOutputType_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__ReplayOutputType_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ReplayOutputType_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The type of :class:`ReplayOutput` to create\n"
		"\n"
		".. data:: Headless\n"
		"\n"
		"  A headless output that does nothing to display to windows but can still be controlled and\n"
		"  queried the same way\n"
		"\n"
		".. data:: Texture\n"
		"\n"
		"  An output that is used for displaying textures, thumbnails and pixel context\n"
		"\n"
		".. data:: Mesh\n"
		"\n"
		"  An output that will display mesh data previews\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ReplayOutputType_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ReplayOutputType_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ReplayOutputType_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ReplayOutputType,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ReplayOutputType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ReplayOutputType_type};

static SwigPyGetSet MeshDataStage___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__MeshDataStage_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"MeshDataStage.__dict__", (void *) &MeshDataStage___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__MeshDataStage_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__MeshDataStage_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__MeshDataStage_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "MeshDataStage",                          /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_MeshDataStage_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__MeshDataStage_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__MeshDataStage_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__MeshDataStage_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__MeshDataStage_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Describes a particular stage in the geometry transformation pipeline.\n"
		"\n"
		".. data:: VSIn\n"
		"\n"
		"  The inputs to the vertex shader described by the explicit API vertex input bindings.\n"
		"\n"
		".. data:: VSOut\n"
		"\n"
		"  The outputs from the vertex shader corresponding one-to-one to the input elements.\n"
		"\n"
		".. data:: GSOut\n"
		"\n"
		"  The final output from the last stage in the pipeline, be that tessellation or geometry shader.\n"
		"\n"
		"  This has possibly been expanded/multiplied from the inputs\n"
		"\n"
		".. data:: TaskOut\n"
		"\n"
		"  Data from a task/amplification shader.\n"
		"\n"
		".. data:: AmpOut\n"
		"\n"
		"  Data from an amplification shader (alias for :data:`TaskOut`).\n"
		"\n"
		".. data:: MeshOut\n"
		"\n"
		"  Data from a mesh shader.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__MeshDataStage_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__MeshDataStage_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__MeshDataStage_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_MeshDataStage,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__MeshDataStage_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__MeshDataStage_type};

static SwigPyGetSet DebugOverlay___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DebugOverlay_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DebugOverlay.__dict__", (void *) &DebugOverlay___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DebugOverlay_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DebugOverlay_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DebugOverlay_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "DebugOverlay",                           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DebugOverlay_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DebugOverlay_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__DebugOverlay_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__DebugOverlay_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DebugOverlay_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The type of overlay image to render on top of an existing texture view, for debugging\n"
		"purposes.\n"
		"\n"
		"In overlays that refer to the 'current pass', for any API that does not have an explicit notion of a\n"
		"render pass, it is defined as all previous drawcalls that render to the same set of render targets.\n"
		"Note that this is defined independently from any marker regions.\n"
		"\n"
		"See :ref:`the documentation for this feature <render-overlay>`.\n"
		"\n"
		".. data:: NoOverlay\n"
		"\n"
		"  No overlay should be rendered.\n"
		"\n"
		".. data:: Drawcall\n"
		"\n"
		"  An overlay highlighting the area rasterized by the drawcall on screen, no matter what tests or\n"
		"  processes may be discarding the pixels actually rendered.\n"
		"\n"
		"  The rest of the image should be dimmed slightly to make the draw on screen clearer.\n"
		"\n"
		".. data:: Wireframe\n"
		"\n"
		"  Similar to the :data:`Drawcall` overlay, this should render over the top of the image, but showing\n"
		"  the wireframe of the object instead of a solid render.\n"
		"\n"
		".. data:: Depth\n"
		"\n"
		"  This overlay shows pixels from the object that passed all depth tests in green, and pixels that\n"
		"  failed any depth test in red.\n"
		"\n"
		"  If some pixel is overwritten more than once by the object, if any of the samples passed the result\n"
		"  will be green (i.e. the failure overlay is conservative).\n"
		"\n"
		".. data:: Stencil\n"
		"\n"
		"  This overlay shows pixels from the object that passed all stencil tests in green, and pixels that\n"
		"  failed any stencil test in red.\n"
		"\n"
		"  If some pixel is overwritten more than once by the object, if any of the samples passed the result\n"
		"  will be green (i.e. the failure overlay is conservative).\n"
		"\n"
		".. data:: BackfaceCull\n"
		"\n"
		"  This overlay shows pixels from the object that passed backface culling in green, and pixels that\n"
		"  were backface culled in red.\n"
		"\n"
		"  If some pixel is overwritten more than once by the object, if any of the samples passed the result\n"
		"  will be green (i.e. the failure overlay is conservative).\n"
		"\n"
		".. data:: ViewportScissor\n"
		"\n"
		"  This overlay shows a rectangle on screen corresponding to both the current viewport, and if\n"
		"  enabled the current scissor as well.\n"
		"\n"
		".. data:: NaN\n"
		"\n"
		"  This overlay renders the image in greyscale using a simple luminosity calculation, then highlights\n"
		"  any pixels that are ``NaN`` in red, any that are positive or negative infinity in green, and any\n"
		"  that are negative in blue.\n"
		"\n"
		".. data:: Clipping\n"
		"\n"
		"  This overlay renders the image in greyscale using a simple luminosity calculation, then highlights\n"
		"  any pixels that are currently above the white point in green and any pixels that are below the\n"
		"  black point in red.\n"
		"\n"
		"  This is relative to the current black and white points used to display the texture.\n"
		"\n"
		".. data:: ClearBeforePass\n"
		"\n"
		"  This overlay clears the bound render targets before the current pass, allowing you to see only the\n"
		"  contribution from the current pass.\n"
		"\n"
		"  Note only color targets are cleared, depth-stencil targets are unchanged so any depth or stencil\n"
		"  tests will still pass or fail in the same way.\n"
		"\n"
		".. data:: ClearBeforeDraw\n"
		"\n"
		"  This is the same as the :data:`ClearBeforePass` overlay, except it clears before the current\n"
		"  drawcall, not the current pass.\n"
		"\n"
		".. data:: QuadOverdrawPass\n"
		"\n"
		"  This overlay shows pixel overdraw using 2x2 rasterized quad granularity instead of single-pixel\n"
		"  overdraw. This represents the number of times the pixel shader was invoked along triangle edges\n"
		"  even if each pixel is only overdrawn once.\n"
		"\n"
		"  The overlay accounts for all draws in the current pass.\n"
		"\n"
		".. data:: QuadOverdrawDraw\n"
		"\n"
		"  This is the same as the :data:`QuadOverdrawPass` overlay, except it only shows the overdraw for\n"
		"  the current drawcall, not the current pass.\n"
		"\n"
		".. data:: TriangleSizePass\n"
		"\n"
		"  This overlay shows the size of each triangle, starting from triangles with area ``16 (4x4)`` and above\n"
		"  at the lower end to triangles with area ``0.125 (1/8th pixel)`` at the upper end.\n"
		"\n"
		"  The overlay accounts for all draws in the current pass.\n"
		"\n"
		".. data:: TriangleSizeDraw\n"
		"\n"
		"  This is similar to the :data:`TriangleSizePass` overlay, except it only shows the triangle size\n"
		"  for the current drawcall, not the current pass.\n"
		"\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DebugOverlay_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DebugOverlay_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DebugOverlay_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DebugOverlay,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DebugOverlay_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DebugOverlay_type};

static SwigPyGetSet FileType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__FileType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"FileType.__dict__", (void *) &FileType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__FileType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__FileType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__FileType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "FileType",                               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_FileType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__FileType_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__FileType_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__FileType_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__FileType_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The format of an image file\n"
		"\n"
		".. data:: DDS\n"
		"\n"
		"  A DDS file\n"
		"\n"
		".. data:: PNG\n"
		"\n"
		"  A PNG file\n"
		"\n"
		".. data:: JPG\n"
		"\n"
		"  A JPG file\n"
		"\n"
		".. data:: BMP\n"
		"\n"
		"  A BMP file\n"
		"\n"
		".. data:: TGA\n"
		"\n"
		"  A TGA file\n"
		"\n"
		".. data:: HDR\n"
		"\n"
		"  An HDR file\n"
		"\n"
		".. data:: EXR\n"
		"\n"
		"  An EXR file\n"
		"\n"
		".. data:: Raw\n"
		"\n"
		"  Raw data, just the bytes of the image tightly packed with no metadata or compression/encoding\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__FileType_richcompare,            /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__FileType_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__FileType_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_FileType,            /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__FileType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__FileType_type};

static SwigPyGetSet AlphaMapping___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__AlphaMapping_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"AlphaMapping.__dict__", (void *) &AlphaMapping___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__AlphaMapping_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__AlphaMapping_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__AlphaMapping_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "AlphaMapping",                           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_AlphaMapping_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__AlphaMapping_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__AlphaMapping_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__AlphaMapping_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__AlphaMapping_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"What to do with the alpha channel from a texture while saving out to a file.\n"
		"\n"
		".. data:: Discard\n"
		"\n"
		"  Completely discard the alpha channel and only write RGB to the file.\n"
		"\n"
		".. data:: BlendToColor\n"
		"\n"
		"  Blend to the primary background color using alpha.\n"
		"\n"
		".. data:: BlendToCheckerboard\n"
		"\n"
		"  Blend to a checkerboard pattern with the primary and secondary background colors.\n"
		"\n"
		".. data:: Preserve\n"
		"\n"
		"  Preserve the alpha channel and save it to the file by itself.\n"
		"\n"
		"  This is only valid for file formats that support alpha channels.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__AlphaMapping_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__AlphaMapping_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__AlphaMapping_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_AlphaMapping,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__AlphaMapping_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__AlphaMapping_type};

static SwigPyGetSet ResourceFormatType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ResourceFormatType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ResourceFormatType.__dict__", (void *) &ResourceFormatType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ResourceFormatType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ResourceFormatType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ResourceFormatType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ResourceFormatType",                     /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ResourceFormatType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ResourceFormatType_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__ResourceFormatType_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__ResourceFormatType_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ResourceFormatType_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A resource format's particular type. This accounts for either block-compressed textures\n"
		"or formats that don't have equal byte-multiple sizes for each channel.\n"
		"\n"
		".. data:: Regular\n"
		"\n"
		"  This format has no special layout, so its format is described by a number of components, a\n"
		"  :class:`CompType` and a byte width per component.\n"
		"\n"
		".. data:: Undefined\n"
		"\n"
		"  This format is undefined or unknown, or does not map to any known regular format.\n"
		"\n"
		".. data:: BC1\n"
		"\n"
		"  A block-compressed texture in ``BC1`` format (RGB with 1-bit alpha, 0.5 bytes per pixel)\n"
		"\n"
		"  Formerly known as ``DXT1``, commonly used for color maps.\n"
		"\n"
		".. data:: BC2\n"
		"\n"
		"  A block-compressed texture in ``BC2`` format (RGB with 4-bit alpha, 1 byte per pixel)\n"
		"\n"
		"  Formerly known as ``DXT3``, rarely used.\n"
		"\n"
		".. data:: BC3\n"
		"\n"
		"  A block-compressed texture in ``BC3`` format (RGBA, 1 byte per pixel)\n"
		"\n"
		"  Formerly known as ``DXT5``, commonly used for color + alpha maps, or color with attached\n"
		"  single channel data.\n"
		"\n"
		".. data:: BC4\n"
		"\n"
		"  A block-compressed texture in ``BC4`` format (Single channel, 0.5 bytes per pixel)\n"
		"\n"
		"  Commonly used for single component data such as gloss or height data.\n"
		"\n"
		".. data:: BC5\n"
		"\n"
		"  A block-compressed texture in ``BC5`` format (Two channels, 1 byte per pixel)\n"
		"\n"
		"  Commonly used for normal maps.\n"
		"\n"
		".. data:: BC6\n"
		"\n"
		"  A block-compressed texture in ``BC6`` format (RGB floating point, 1 byte per pixel)\n"
		"\n"
		"  Commonly used for HDR data of all kinds.\n"
		"\n"
		".. data:: BC7\n"
		"\n"
		"  A block-compressed texture in ``BC7`` format (RGB or RGBA, 1 byte per pixel)\n"
		"\n"
		"  Commonly used for high quality color maps, with or without alpha.\n"
		"\n"
		".. data:: ETC2\n"
		"\n"
		"  A block-compressed texture in ``ETC2`` format (RGB with 1-bit alpha, 0.5 bytes per pixel)\n"
		"\n"
		"  Commonly used on mobile or embedded platforms.\n"
		"\n"
		"  Note that the mode added in ``EAC`` with 1 byte per pixel and full 8-bit alpha is\n"
		"  grouped as ``EAC``, with a component count of 4. See :data:`EAC`.\n"
		"\n"
		".. data:: EAC\n"
		"\n"
		"  A block-compressed texture in ``EAC`` format, expanded from ``ETC2``.\n"
		"\n"
		"  Commonly used on mobile or embedded platforms.\n"
		"\n"
		"  The single and dual channel formats encode 11-bit data with 0.5 bytes per channel (so\n"
		"  the single channel format is 0.5 bytes per pixel total, and the dual channel format is 1 byte per\n"
		"  pixel total). The four channel format is encoded similarly to ETC2 for the base RGB data and\n"
		"  similarly to the single channel format for the alpha, giving 1 byte per pixel total.\n"
		"  See :data:`ETC2`.\n"
		"\n"
		".. data:: ASTC\n"
		"\n"
		"  A block-compressed texture in ``ASTC`` format (Representation varies a lot)\n"
		"\n"
		"  The ASTC format encodes each block as 16 bytes, but the block size can vary from 4x4 (so 1 byte\n"
		"  per pixel) up to 12x12 (0.11 bytes per pixel).\n"
		"\n"
		"  Each block can encode between one and three channels of data, either correlated or uncorrelated,\n"
		"  in low or high dynamic range.\n"
		"\n"
		"  Commonly used on mobile or embedded platforms.\n"
		"\n"
		".. data:: R10G10B10A2\n"
		"\n"
		"  Each pixel is stored in 32 bits. Red, green and blue are stored in 10-bits each and alpha in 2\n"
		"  bits. The data can either be :data:`unsigned normalised <CompType.UNorm>` or\n"
		"  :data:`unsigned integer <CompType.UInt>`.\n"
		"\n"
		".. data:: R11G11B10\n"
		"\n"
		"  Each pixel is stored in 32 bits. Red and green are stored as an 11-bit float with no sign bit,\n"
		"  5-bit exponent and 6-bit mantissa. Blue is stored with 5-bit exponent and 5-bit mantissa.\n"
		"\n"
		".. data:: R5G6B5\n"
		"\n"
		"  Each pixel is stored in 16 bits. Red and blue are stored as 5 bits, and green is stored as six.\n"
		"  The data is :data:`unsigned normalised <CompType.UNorm>`.\n"
		"\n"
		".. data:: R5G5B5A1\n"
		"\n"
		"  Each pixel is stored in 16 bits. Red, green, and blue are stored as 5 bits, with 1-bit alpha.\n"
		"  The data is :data:`unsigned normalised <CompType.UNorm>`.\n"
		"\n"
		".. data:: R9G9B9E5\n"
		"\n"
		"  Each pixel is stored in 32 bits. Red, green, and blue are stored with individual 9-bit mantissas\n"
		"  and a shared 5-bit exponent. There are no sign bits.\n"
		"\n"
		".. data:: R4G4B4A4\n"
		"\n"
		"  Each pixel is stored in 16 bits. Red, green, blue, and alpha are stored as 4-bit\n"
		"  :data:`unsigned normalised <CompType.UNorm>` values.\n"
		"\n"
		".. data:: R4G4\n"
		"\n"
		"  Each pixel is stored in 8 bits. Red and green are stored as 4-bit\n"
		"  :data:`unsigned normalised <CompType.UNorm>` values.\n"
		"\n"
		".. data:: D16S8\n"
		"\n"
		"  Each pixel is considered a packed depth-stencil value with 16 bit normalised depth and 8 bit\n"
		"  stencil.\n"
		"\n"
		".. data:: D24S8\n"
		"\n"
		"  Each pixel is considered a packed depth-stencil value with 24 bit normalised depth and 8 bit\n"
		"  stencil.\n"
		"\n"
		".. data:: D32S8\n"
		"\n"
		"  Each pixel is considered a packed depth-stencil value with 32 bit floating point depth and 8 bit\n"
		"  stencil.\n"
		"\n"
		".. data:: S8\n"
		"\n"
		"  Each pixel is an 8 bit stencil value.\n"
		"\n"
		".. data:: YUV8\n"
		"\n"
		"  The pixel data is 8-bit in YUV subsampled format. More information about subsampling setup is\n"
		"  stored separately\n"
		"\n"
		".. data:: YUV10\n"
		"\n"
		"  The pixel data is 10-bit in YUV subsampled format. More information about subsampling setup is\n"
		"  stored separately\n"
		"\n"
		".. data:: YUV12\n"
		"\n"
		"  The pixel data is 12-bit in YUV subsampled format. More information about subsampling setup is\n"
		"  stored separately\n"
		"\n"
		".. data:: YUV16\n"
		"\n"
		"  The pixel data is 16-bit in YUV subsampled format. More information about subsampling setup is\n"
		"  stored separately\n"
		"\n"
		".. data:: PVRTC\n"
		"\n"
		"  PowerVR properitary texture compression format.\n"
		"\n"
		".. data:: A8\n"
		"\n"
		"  8-bit unsigned normalised alpha - equivalent to standard R8 with a pre-baked swizzle.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ResourceFormatType_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ResourceFormatType_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ResourceFormatType_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ResourceFormatType,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ResourceFormatType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ResourceFormatType_type};

static SwigPyGetSet QualityHint___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__QualityHint_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"QualityHint.__dict__", (void *) &QualityHint___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__QualityHint_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__QualityHint_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__QualityHint_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "QualityHint",                            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_QualityHint_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__QualityHint_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__QualityHint_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__QualityHint_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__QualityHint_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"An API specific hint for a certain behaviour. A legacy concept in OpenGL that controls\n"
		"hints to the implementation where there is room for interpretation within the range of valid\n"
		"behaviour.\n"
		"\n"
		".. data:: DontCare\n"
		"\n"
		"  The hinted behaviour can follow any valid path as the implementation decides.\n"
		"\n"
		".. data:: Nicest\n"
		"\n"
		"  The hinted behaviour should follow the most correct or highest quality path.\n"
		"\n"
		".. data:: Fastest\n"
		"\n"
		"  The hinted behaviour should follow the most efficient path.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__QualityHint_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__QualityHint_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__QualityHint_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_QualityHint,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__QualityHint_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__QualityHint_type};

static SwigPyGetSet GPUVendor___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GPUVendor_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GPUVendor.__dict__", (void *) &GPUVendor___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GPUVendor_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GPUVendor_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GPUVendor_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "GPUVendor",                              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GPUVendor_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GPUVendor_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__GPUVendor_type.as_sequence,                   /* tp_as_sequence */
    &SwigPyBuiltin__GPUVendor_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GPUVendor_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Identifies a GPU vendor.\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  A GPU from an unknown vendor\n"
		"\n"
		".. data:: ARM\n"
		"\n"
		"  An ARM GPU\n"
		"\n"
		".. data:: AMD\n"
		"\n"
		"  An AMD GPU\n"
		"\n"
		".. data:: Broadcom\n"
		"\n"
		"  A Broadcom GPU\n"
		"\n"
		".. data:: Imagination\n"
		"\n"
		"  An Imagination GPU\n"
		"\n"
		".. data:: Intel\n"
		"\n"
		"  An Intel GPU\n"
		"\n"
		".. data:: nVidia\n"
		"\n"
		"  An nVidia GPU\n"
		"\n"
		".. data:: Qualcomm\n"
		"\n"
		"  A Qualcomm  GPU\n"
		"\n"
		".. data:: Verisilicon\n"
		"\n"
		"  A Verisilicon or Vivante GPU\n"
		"\n"
		".. data:: Software\n"
		"\n"
		"  A software-rendering emulated GPU\n"
		"\n"
		".. data:: Samsung\n"
		"\n"
		"  A Samsung GPU\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GPUVendor_richcompare,           /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GPUVendor_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GPUVendor_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GPUVendor,           /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GPUVendor_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GPUVendor_type};

static SwigPyGetSet GraphicsAPI___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GraphicsAPI_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GraphicsAPI.__dict__", (void *) &GraphicsAPI___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GraphicsAPI_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GraphicsAPI_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GraphicsAPI_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "GraphicsAPI",                            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GraphicsAPI_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GraphicsAPI_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__GraphicsAPI_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__GraphicsAPI_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GraphicsAPI_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Identifies a Graphics API.\n"
		"\n"
		".. data:: D3D11\n"
		"\n"
		"  Direct3D 11.\n"
		"\n"
		".. data:: D3D12\n"
		"\n"
		"  Direct3D 12.\n"
		"\n"
		".. data:: OpenGL\n"
		"\n"
		"  OpenGL.\n"
		"\n"
		".. data:: Vulkan\n"
		"\n"
		"  Vulkan.\n"
		"\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GraphicsAPI_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GraphicsAPI_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GraphicsAPI_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GraphicsAPI,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GraphicsAPI_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GraphicsAPI_type};

static SwigPyGetSet ShaderEncoding___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderEncoding_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderEncoding.__dict__", (void *) &ShaderEncoding___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderEncoding_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderEncoding_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderEncoding_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ShaderEncoding",                         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderEncoding_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderEncoding_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__ShaderEncoding_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__ShaderEncoding_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderEncoding_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Identifies a shader encoding used to pass shader code to an API.\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  Unknown or unprocessable format.\n"
		"\n"
		".. data:: DXBC\n"
		"\n"
		"  DXBC binary shader, used by D3D11 and D3D12.\n"
		"\n"
		".. data:: GLSL\n"
		"\n"
		"  GLSL in string format, used by OpenGL.\n"
		"\n"
		".. data:: SPIRV\n"
		"\n"
		"  SPIR-V binary shader, as used by Vulkan. This format is technically not distinct from\n"
		"  :data:`OpenGLSPIRV` but is considered unique here since it really *should* have been a different\n"
		"  format, and introducing a separation allows better selection of tools automatically.\n"
		"\n"
		".. data:: SPIRVAsm\n"
		"\n"
		"  Canonical SPIR-V assembly form, used (indirectly via :data:`SPIRV`) by Vulkan. See :data:`SPIRV`.\n"
		"\n"
		".. data:: OpenGLSPIRV\n"
		"\n"
		"  SPIR-V binary shader, as used by OpenGL. This format is technically not distinct from\n"
		"  :data:`VulkanSPIRV` but is considered unique here since it really *should* have been a different\n"
		"  format, and introducing a separation allows better selection of tools automatically.\n"
		"\n"
		".. data:: OpenGLSPIRVAsm\n"
		"\n"
		"  Canonical SPIR-V assembly form, used (indirectly via :data:`OpenGLSPIRV`) by OpenGL. See\n"
		"  :data:`OpenGLSPIRV` and note that it's artificially differentiated from :data:`SPIRVAsm`.\n"
		"\n"
		".. data:: HLSL\n"
		"\n"
		"  HLSL in string format, used by D3D11, D3D12, and Vulkan/GL via compilation to SPIR-V.\n"
		"\n"
		".. data:: DXIL\n"
		"\n"
		"  DXIL binary shader, used by D3D12. Note that although the container is still DXBC format this is\n"
		"  used to distinguish from :data:`DXBC` for compiler I/O matching.\n"
		"\n"
		".. data:: Slang\n"
		"\n"
		"  Slang in string format, used by the slang compiler for compilation to multiple backend formats.\n"
		"\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderEncoding_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderEncoding_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderEncoding_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderEncoding,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderEncoding_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderEncoding_type};

static SwigPyGetSet KnownShaderTool___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__KnownShaderTool_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"KnownShaderTool.__dict__", (void *) &KnownShaderTool___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__KnownShaderTool_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__KnownShaderTool_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__KnownShaderTool_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "KnownShaderTool",                        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_KnownShaderTool_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__KnownShaderTool_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__KnownShaderTool_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__KnownShaderTool_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__KnownShaderTool_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Identifies a particular known tool used for shader processing.\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  Corresponds to no known tool.\n"
		"\n"
		".. data:: SPIRV_Cross\n"
		"\n"
		"  `SPIRV-Cross <https://github.com/KhronosGroup/SPIRV-Cross>`_\n"
		"   targetting normal Vulkan flavoured SPIR-V.\n"
		"\n"
		".. data:: SPIRV_Cross_OpenGL\n"
		"\n"
		"  `SPIRV-Cross <https://github.com/KhronosGroup/SPIRV-Cross>`_\n"
		"   targetting OpenGL extension flavoured SPIR-V.\n"
		"\n"
		".. data:: spirv_dis\n"
		"\n"
		"  `spirv-dis from SPIRV-Tools <https://github.com/KhronosGroup/SPIRV-Tools>`_\n"
		"   targetting normal Vulkan flavoured SPIR-V.\n"
		"\n"
		".. data:: spirv_dis_OpenGL\n"
		"\n"
		"  `spirv-dis from SPIRV-Tools <https://github.com/KhronosGroup/SPIRV-Tools>`_\n"
		"   targetting OpenGL extension flavoured SPIR-V.\n"
		"\n"
		".. data:: glslangValidatorGLSL\n"
		"\n"
		"  `glslang compiler (GLSL) <https://github.com/KhronosGroup/glslang>`_\n"
		"   targetting normal Vulkan flavoured SPIR-V.\n"
		"\n"
		".. data:: glslangValidatorGLSL_OpenGL\n"
		"\n"
		"  `glslang compiler (GLSL) <https://github.com/KhronosGroup/glslang>`_\n"
		"   targetting OpenGL extension flavoured SPIR-V.\n"
		"\n"
		".. data:: glslangValidatorHLSL\n"
		"\n"
		"  `glslang compiler (HLSL) <https://github.com/KhronosGroup/glslang>`_.\n"
		"\n"
		".. data:: spirv_as\n"
		"\n"
		"  `spirv-as from SPIRV-Tools <https://github.com/KhronosGroup/SPIRV-Tools>`_\n"
		"   targetting normal Vulkan flavoured SPIR-V.\n"
		"\n"
		".. data:: spirv_as_OpenGL\n"
		"\n"
		"  `spirv-as from SPIRV-Tools <https://github.com/KhronosGroup/SPIRV-Tools>`_\n"
		"   targetting OpenGL extension flavoured SPIR-V.\n"
		"\n"
		".. data:: dxcSPIRV\n"
		"\n"
		"  `DirectX Shader Compiler <https://github.com/microsoft/DirectXShaderCompiler>`_ with Vulkan SPIR-V\n"
		"   output.\n"
		"\n"
		".. data:: dxcDXIL\n"
		"\n"
		"  `DirectX Shader Compiler <https://github.com/microsoft/DirectXShaderCompiler>`_ with DXIL output.\n"
		"\n"
		".. data:: fxc\n"
		"\n"
		"  fxc Shader Compiler with DXBC output.\n"
		"\n"
		".. data:: slangSPIRV\n"
		"\n"
		"  `Slang Shader Compiler <https://github.com/shader-slang/slang>`_ with Vulkan SPIR-V output.\n"
		"\n"
		".. data:: slangDXIL\n"
		"\n"
		"  `Slang Shader Compiler <https://github.com/shader-slang/slang>`_ with DXIL output.\n"
		"\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__KnownShaderTool_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__KnownShaderTool_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__KnownShaderTool_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_KnownShaderTool,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__KnownShaderTool_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__KnownShaderTool_type};

static SwigPyGetSet Topology___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__Topology_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"Topology.__dict__", (void *) &Topology___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__Topology_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__Topology_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__Topology_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "Topology",                               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_Topology_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__Topology_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__Topology_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__Topology_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__Topology_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A primitive topology used for processing vertex data.\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  An unknown or undefined topology.\n"
		"\n"
		".. data:: PointList\n"
		"\n"
		"  A point list.\n"
		"\n"
		".. data:: LineList\n"
		"\n"
		"  A line list.\n"
		"\n"
		".. data:: LineStrip\n"
		"\n"
		"  A line strip.\n"
		"\n"
		".. data:: LineLoop\n"
		"\n"
		"  A line loop.\n"
		"\n"
		".. data:: TriangleList\n"
		"\n"
		"  A triangle list.\n"
		"\n"
		".. data:: TriangleStrip\n"
		"\n"
		"  A triangle strip.\n"
		"\n"
		".. data:: TriangleFan\n"
		"\n"
		"  A triangle fan.\n"
		"\n"
		".. data:: LineList_Adj\n"
		"\n"
		"  A line list with adjacency information.\n"
		"\n"
		".. data:: LineStrip_Adj\n"
		"\n"
		"  A line strip with adjacency information.\n"
		"\n"
		".. data:: TriangleList_Adj\n"
		"\n"
		"  A triangle list with adjacency information.\n"
		"\n"
		".. data:: TriangleStrip_Adj\n"
		"\n"
		"  A triangle strip with adjacency information.\n"
		"\n"
		".. data:: PatchList\n"
		"\n"
		"  An alias for :data:`PatchList_1CPs`.\n"
		"\n"
		".. data:: PatchList_1CPs\n"
		"\n"
		"  A patch list with 1 control points.\n"
		"\n"
		".. data:: PatchList_2CPs\n"
		"\n"
		"  A patch list with 2 control points.\n"
		"\n"
		".. data:: PatchList_3CPs\n"
		"\n"
		"  A patch list with 3 control points.\n"
		"\n"
		".. data:: PatchList_4CPs\n"
		"\n"
		"  A patch list with 4 control points.\n"
		"\n"
		".. data:: PatchList_5CPs\n"
		"\n"
		"  A patch list with 5 control points.\n"
		"\n"
		".. data:: PatchList_6CPs\n"
		"\n"
		"  A patch list with 6 control points.\n"
		"\n"
		".. data:: PatchList_7CPs\n"
		"\n"
		"  A patch list with 7 control points.\n"
		"\n"
		".. data:: PatchList_8CPs\n"
		"\n"
		"  A patch list with 8 control points.\n"
		"\n"
		".. data:: PatchList_9CPs\n"
		"\n"
		"  A patch list with 9 control points.\n"
		"\n"
		".. data:: PatchList_10CPs\n"
		"\n"
		"  A patch list with 10 control points.\n"
		"\n"
		".. data:: PatchList_11CPs\n"
		"\n"
		"  A patch list with 11 control points.\n"
		"\n"
		".. data:: PatchList_12CPs\n"
		"\n"
		"  A patch list with 12 control points.\n"
		"\n"
		".. data:: PatchList_13CPs\n"
		"\n"
		"  A patch list with 13 control points.\n"
		"\n"
		".. data:: PatchList_14CPs\n"
		"\n"
		"  A patch list with 14 control points.\n"
		"\n"
		".. data:: PatchList_15CPs\n"
		"\n"
		"  A patch list with 15 control points.\n"
		"\n"
		".. data:: PatchList_16CPs\n"
		"\n"
		"  A patch list with 16 control points.\n"
		"\n"
		".. data:: PatchList_17CPs\n"
		"\n"
		"  A patch list with 17 control points.\n"
		"\n"
		".. data:: PatchList_18CPs\n"
		"\n"
		"  A patch list with 18 control points.\n"
		"\n"
		".. data:: PatchList_19CPs\n"
		"\n"
		"  A patch list with 19 control points.\n"
		"\n"
		".. data:: PatchList_20CPs\n"
		"\n"
		"  A patch list with 20 control points.\n"
		"\n"
		".. data:: PatchList_21CPs\n"
		"\n"
		"  A patch list with 21 control points.\n"
		"\n"
		".. data:: PatchList_22CPs\n"
		"\n"
		"  A patch list with 22 control points.\n"
		"\n"
		".. data:: PatchList_23CPs\n"
		"\n"
		"  A patch list with 23 control points.\n"
		"\n"
		".. data:: PatchList_24CPs\n"
		"\n"
		"  A patch list with 24 control points.\n"
		"\n"
		".. data:: PatchList_25CPs\n"
		"\n"
		"  A patch list with 25 control points.\n"
		"\n"
		".. data:: PatchList_26CPs\n"
		"\n"
		"  A patch list with 26 control points.\n"
		"\n"
		".. data:: PatchList_27CPs\n"
		"\n"
		"  A patch list with 27 control points.\n"
		"\n"
		".. data:: PatchList_28CPs\n"
		"\n"
		"  A patch list with 28 control points.\n"
		"\n"
		".. data:: PatchList_29CPs\n"
		"\n"
		"  A patch list with 29 control points.\n"
		"\n"
		".. data:: PatchList_30CPs\n"
		"\n"
		"  A patch list with 30 control points.\n"
		"\n"
		".. data:: PatchList_31CPs\n"
		"\n"
		"  A patch list with 31 control points.\n"
		"\n"
		".. data:: PatchList_32CPs\n"
		"\n"
		"  A patch list with 32 control points.\n"
		"\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__Topology_richcompare,            /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__Topology_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__Topology_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_Topology,            /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__Topology_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__Topology_type};

static SwigPyGetSet ShaderStage___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderStage_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderStage.__dict__", (void *) &ShaderStage___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderStage_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderStage_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderStage_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ShaderStage",                            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderStage_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderStage_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__ShaderStage_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__ShaderStage_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderStage_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The stage in a pipeline where a shader runs\n"
		"\n"
		".. data:: Vertex\n"
		"\n"
		"  The vertex shader.\n"
		"\n"
		".. data:: Hull\n"
		"\n"
		"  The hull shader. See also :data:`Tess_Control`.\n"
		"\n"
		".. data:: Tess_Control\n"
		"\n"
		"  The tessellation control shader. See also :data:`Hull`.\n"
		"\n"
		".. data:: Domain\n"
		"\n"
		"  The domain shader. See also :data:`Tess_Eval`.\n"
		"\n"
		".. data:: Tess_Eval\n"
		"\n"
		"  The tessellation evaluation shader. See also :data:`Domain`.\n"
		"\n"
		".. data:: Geometry\n"
		"\n"
		"  The geometry shader.\n"
		"\n"
		".. data:: Pixel\n"
		"\n"
		"  The pixel shader. See also :data:`Fragment`.\n"
		"\n"
		".. data:: Fragment\n"
		"\n"
		"  The fragment shader. See also :data:`Pixel`.\n"
		"\n"
		".. data:: Compute\n"
		"\n"
		"  The compute shader.\n"
		"\n"
		".. data:: Amplification\n"
		"\n"
		"  The amplification shader. See also :data:`Task`.\n"
		"\n"
		".. data:: Task\n"
		"\n"
		"  The task shader. See also :data:`Amplification`.\n"
		"\n"
		".. data:: Mesh\n"
		"\n"
		"  The mesh shader.\n"
		"\n"
		".. data:: RayGen\n"
		"\n"
		"  A ray generation shader, called from a ray dispatch command to launch initial rays.\n"
		"\n"
		".. data:: Intersection\n"
		"\n"
		"  An intersection shader, used for procedural objects in a BLAS to calculate hits.\n"
		"\n"
		".. data:: AnyHit\n"
		"\n"
		"  An any-hit shader, called in an indeterminate order and number when a ray intersection has been\n"
		"  found with an object but may not be the final hit.\n"
		"\n"
		".. data:: ClosestHit\n"
		"\n"
		"  A closest-hit shader, called once the closest hit on a ray has been found.\n"
		"\n"
		".. data:: Miss\n"
		"\n"
		"  A miss shader, called when a ray has no valid closest hit at all.\n"
		"\n"
		".. data:: Callable\n"
		"\n"
		"  A callable shader, called by shader code via index during ray processing.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderStage_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderStage_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderStage_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderStage,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderStage_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderStage_type};

static SwigPyGetSet MessageCategory___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__MessageCategory_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"MessageCategory.__dict__", (void *) &MessageCategory___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__MessageCategory_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__MessageCategory_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__MessageCategory_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "MessageCategory",                        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_MessageCategory_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__MessageCategory_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__MessageCategory_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__MessageCategory_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__MessageCategory_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The type of issue that a debug message is about.\n"
		"\n"
		".. data:: Application_Defined\n"
		"\n"
		"  This message was generated by the application.\n"
		"\n"
		".. data:: Miscellaneous\n"
		"\n"
		"  This message doesn't fall into any other pre-defined category.\n"
		"\n"
		".. data:: Initialization\n"
		"\n"
		"  This message is about initialisation or creation of objects.\n"
		"\n"
		".. data:: Cleanup\n"
		"\n"
		"  This message is about cleanup, destruction or shutdown of objects.\n"
		"\n"
		".. data:: Compilation\n"
		"\n"
		"  This message is about compilation of shaders.\n"
		"\n"
		".. data:: State_Creation\n"
		"\n"
		"  This message is about creating unified state objects.\n"
		"\n"
		".. data:: State_Setting\n"
		"\n"
		"  This message is about changing current pipeline state.\n"
		"\n"
		".. data:: State_Getting\n"
		"\n"
		"  This message is about fetching or retrieving current pipeline state.\n"
		"\n"
		".. data:: Resource_Manipulation\n"
		"\n"
		"  This message is about updating or changing a resource's properties or contents.\n"
		"\n"
		".. data:: Execution\n"
		"\n"
		"  This message is about performing work.\n"
		"\n"
		".. data:: Shaders\n"
		"\n"
		"  This message is about the use, syntax, binding or linkage of shaders.\n"
		"\n"
		".. data:: Deprecated\n"
		"\n"
		"  This message is about the use of deprecated functionality.\n"
		"\n"
		".. data:: Undefined\n"
		"\n"
		"  This message is about the use of undefined behaviour.\n"
		"\n"
		".. data:: Portability\n"
		"\n"
		"  This message is about behaviour that could be or is not portable between different environments.\n"
		"\n"
		".. data:: Performance\n"
		"\n"
		"  This message is about performance problems or pitfalls.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__MessageCategory_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__MessageCategory_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__MessageCategory_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_MessageCategory,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__MessageCategory_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__MessageCategory_type};

static SwigPyGetSet MessageSeverity___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__MessageSeverity_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"MessageSeverity.__dict__", (void *) &MessageSeverity___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__MessageSeverity_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__MessageSeverity_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__MessageSeverity_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "MessageSeverity",                        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_MessageSeverity_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__MessageSeverity_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__MessageSeverity_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__MessageSeverity_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__MessageSeverity_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"How serious a debug message is\n"
		"\n"
		".. data:: High\n"
		"\n"
		"  This message is very serious, indicating a guaranteed problem or major flaw.\n"
		"\n"
		".. data:: Medium\n"
		"\n"
		"  This message is somewhat serious, indicating a problem that should be addressed or investigated.\n"
		"\n"
		".. data:: Low\n"
		"\n"
		"  This message is not very serious. This indicates something that might indicate a problem.\n"
		"\n"
		".. data:: Info\n"
		"\n"
		"  This message is not about a problem but is purely informational.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__MessageSeverity_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__MessageSeverity_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__MessageSeverity_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_MessageSeverity,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__MessageSeverity_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__MessageSeverity_type};

static SwigPyGetSet MessageSource___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__MessageSource_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"MessageSource.__dict__", (void *) &MessageSource___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__MessageSource_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__MessageSource_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__MessageSource_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "MessageSource",                          /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_MessageSource_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__MessageSource_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__MessageSource_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__MessageSource_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__MessageSource_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Where a debug message was reported from\n"
		"\n"
		".. data:: API\n"
		"\n"
		"  This message comes from the API's debugging or validation layers.\n"
		"\n"
		".. data:: RedundantAPIUse\n"
		"\n"
		"  This message comes from detecting redundant API calls - calls with no side-effect or purpose, e.g.\n"
		"  setting state that is already set.\n"
		"\n"
		".. data:: IncorrectAPIUse\n"
		"\n"
		"  This message comes from detecting incorrect use of the API.\n"
		"\n"
		".. data:: GeneralPerformance\n"
		"\n"
		"  This message comes from detecting general performance problems that are not hardware or platform\n"
		"  specific.\n"
		"\n"
		".. data:: GCNPerformance\n"
		"\n"
		"  This message comes from detecting patterns that will cause performance problems on GCN-based\n"
		"  hardware.\n"
		"\n"
		".. data:: RuntimeWarning\n"
		"\n"
		"  This message comes not from inspecting the log but something detected at runtime while in use,\n"
		"  for example exceptions generated during shader debugging.\n"
		"\n"
		".. data:: UnsupportedConfiguration\n"
		"\n"
		"  This message comes from replaying a capture in an environment with insufficient capability to\n"
		"  accurately reproduce the API work. Either this means the replay will be wrong, or it may be that\n"
		"  depending on the exact API work some inaccuracies might happen.\n"
		"\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__MessageSource_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__MessageSource_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__MessageSource_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_MessageSource,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__MessageSource_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__MessageSource_type};

static SwigPyGetSet ResourceUsage___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ResourceUsage_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ResourceUsage.__dict__", (void *) &ResourceUsage___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ResourceUsage_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ResourceUsage_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ResourceUsage_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ResourceUsage",                          /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ResourceUsage_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ResourceUsage_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__ResourceUsage_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__ResourceUsage_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ResourceUsage_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"How a resource is being used in the pipeline at a particular point.\n"
		"\n"
		"Note that a resource may be used for more than one thing in one event, see :class:`EventUsage`.\n"
		"\n"
		".. data:: Unused\n"
		"\n"
		"  The resource is not being used.\n"
		"\n"
		".. data:: VertexBuffer\n"
		"\n"
		"  The resource is being used as a fixed-function vertex buffer input.\n"
		"\n"
		".. data:: IndexBuffer\n"
		"\n"
		"  The resource is being used as an index buffer.\n"
		"\n"
		".. data:: VS_Constants\n"
		"\n"
		"  The resource is being used for constants in the :data:`vertex shader <ShaderStage.Vertex>`.\n"
		"\n"
		".. data:: HS_Constants\n"
		"\n"
		"  The resource is being used for constants in the tessellation control or\n"
		"  :data:`hull shader <ShaderStage.Hull>`.\n"
		"\n"
		".. data:: DS_Constants\n"
		"\n"
		"  The resource is being used for constants in the tessellation evaluation or\n"
		"  :data:`domain shader <ShaderStage.Domain>`.\n"
		"\n"
		".. data:: GS_Constants\n"
		"\n"
		"  The resource is being used for constants in the :data:`geometry shader <ShaderStage.Geometry>`.\n"
		"\n"
		".. data:: PS_Constants\n"
		"\n"
		"  The resource is being used for constants in the :data:`pixel shader <ShaderStage.Pixel>`.\n"
		"\n"
		".. data:: CS_Constants\n"
		"\n"
		"  The resource is being used for constants in the :data:`compute shader <ShaderStage.Compute>`.\n"
		"\n"
		".. data:: TS_Constants\n"
		"\n"
		"  The resource is being used as a constants in the amplification or\n"
		"  :data:`task shader <ShaderStage.Task>`.\n"
		"\n"
		".. data:: MS_Constants\n"
		"\n"
		"  The resource is being used as a constants in the :data:`mesh shader <ShaderStage.Mesh>`.\n"
		"\n"
		".. data:: All_Constants\n"
		"\n"
		"  The resource is being used for constants in all shader stages.\n"
		"\n"
		".. data:: StreamOut\n"
		"\n"
		"  The resource is being used for stream out/transform feedback storage after geometry processing.\n"
		"\n"
		".. data:: VS_Resource\n"
		"\n"
		"  The resource is being used as a read-only resource in the\n"
		"  :data:`vertex shader <ShaderStage.Vertex>`.\n"
		"\n"
		".. data:: HS_Resource\n"
		"\n"
		"  The resource is being used as a read-only resource in the tessellation control or\n"
		"  :data:`hull shader <ShaderStage.Hull>`.\n"
		"\n"
		".. data:: DS_Resource\n"
		"\n"
		"  The resource is being used as a read-only resource in the tessellation evaluation or\n"
		"  :data:`domain shader <ShaderStage.Domain>`.\n"
		"\n"
		".. data:: GS_Resource\n"
		"\n"
		"  The resource is being used as a read-only resource in the\n"
		"  :data:`geometry shader <ShaderStage.Geometry>`.\n"
		"\n"
		".. data:: PS_Resource\n"
		"\n"
		"  The resource is being used as a read-only resource in the\n"
		"  :data:`pixel shader <ShaderStage.Pixel>`.\n"
		"\n"
		".. data:: CS_Resource\n"
		"\n"
		"  The resource is being used as a read-only resource in the\n"
		"  :data:`compute shader <ShaderStage.Compute>`.\n"
		"\n"
		".. data:: TS_Resource\n"
		"\n"
		"  The resource is being used as a read-only resource in the amplification or\n"
		"  :data:`task shader <ShaderStage.Task>`.\n"
		"\n"
		".. data:: MS_Resource\n"
		"\n"
		"  The resource is being used as a read-only resource in the\n"
		"  :data:`mesh shader <ShaderStage.Mesh>`.\n"
		"\n"
		".. data:: All_Resource\n"
		"\n"
		"  The resource is being used as a read-only resource in all shader stages.\n"
		"\n"
		"\n"
		".. data:: VS_RWResource\n"
		"\n"
		"  The resource is being used as a read-write resource in the\n"
		"  :data:`vertex shader <ShaderStage.Vertex>`.\n"
		"\n"
		".. data:: HS_RWResource\n"
		"\n"
		"  The resource is being used as a read-write resource in the tessellation control or\n"
		"  :data:`hull shader <ShaderStage.Hull>`.\n"
		"\n"
		".. data:: DS_RWResource\n"
		"\n"
		"  The resource is being used as a read-write resource in the tessellation evaluation or\n"
		"  :data:`domain shader <ShaderStage.Domain>`.\n"
		"\n"
		".. data:: GS_RWResource\n"
		"\n"
		"  The resource is being used as a read-write resource in the\n"
		"  :data:`geometry shader <ShaderStage.Geometry>`.\n"
		"\n"
		".. data:: PS_RWResource\n"
		"\n"
		"  The resource is being used as a read-write resource in the\n"
		"  :data:`pixel shader <ShaderStage.Pixel>`.\n"
		"\n"
		".. data:: CS_RWResource\n"
		"\n"
		"  The resource is being used as a read-write resource in the\n"
		"  :data:`compute shader <ShaderStage.Compute>`.\n"
		"\n"
		".. data:: TS_RWResource\n"
		"\n"
		"  The resource is being used as a read-write resource in the amplification or\n"
		"  :data:`task shader <ShaderStage.Task>`.\n"
		"\n"
		".. data:: MS_RWResource\n"
		"\n"
		"  The resource is being used as a read-write resource in the\n"
		"  :data:`mesh shader <ShaderStage.Mesh>`.\n"
		"\n"
		".. data:: All_RWResource\n"
		"\n"
		"  The resource is being used as a read-write resource in all shader stages.\n"
		"\n"
		".. data:: InputTarget\n"
		"\n"
		"  The resource is being read as an input target for reading from the target currently being written.\n"
		"\n"
		".. data:: ColorTarget\n"
		"\n"
		"  The resource is being written to as a color output.\n"
		"\n"
		".. data:: DepthStencilTarget\n"
		"\n"
		"  The resource is being written to and tested against as a depth-stencil output.\n"
		"\n"
		".. data:: Indirect\n"
		"\n"
		"  The resource is being used for indirect arguments.\n"
		"\n"
		".. data:: Clear\n"
		"\n"
		"  The resource is being cleared.\n"
		"\n"
		".. data:: Discard\n"
		"\n"
		"  The resource contents are discarded explicitly or implicitly.\n"
		"\n"
		".. data:: GenMips\n"
		"\n"
		"  The resource is having mips generated for it.\n"
		"\n"
		".. data:: Resolve\n"
		"\n"
		"  The resource is being resolved or blitted, as both source and destination.\n"
		"\n"
		".. data:: ResolveSrc\n"
		"\n"
		"  The resource is being resolved or blitted from.\n"
		"\n"
		".. data:: ResolveDst\n"
		"\n"
		"  The resource is being resolved or blitted to.\n"
		"\n"
		".. data:: Copy\n"
		"\n"
		"  The resource is being copied, as both source and destination.\n"
		"\n"
		".. data:: CopySrc\n"
		"\n"
		"  The resource is being copied from.\n"
		"\n"
		".. data:: CopyDst\n"
		"\n"
		"  The resource is being copied to.\n"
		"\n"
		".. data:: Barrier\n"
		"\n"
		"  The resource is being specified in a barrier, as defined in Vulkan or Direct3D 12.\n"
		"\n"
		".. data:: CPUWrite\n"
		"\n"
		"  The resource is written from the CPU, either directly as mapped memory or indirectly via a\n"
		"  synchronous update.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ResourceUsage_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ResourceUsage_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ResourceUsage_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ResourceUsage,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ResourceUsage_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ResourceUsage_type};

static SwigPyGetSet Visualisation___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__Visualisation_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"Visualisation.__dict__", (void *) &Visualisation___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__Visualisation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__Visualisation_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__Visualisation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "Visualisation",                          /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_Visualisation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__Visualisation_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__Visualisation_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__Visualisation_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__Visualisation_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"What kind of visualisation to use when rendering a mesh.\n"
		"\n"
		".. data:: NoSolid\n"
		"\n"
		"  No solid shading should be done.\n"
		"\n"
		".. data:: Solid\n"
		"\n"
		"  The mesh should be rendered in a single flat unshaded color.\n"
		"\n"
		".. data:: Lit\n"
		"\n"
		"  The mesh should be rendered with face normals generated on the primitives and used for lighting.\n"
		"\n"
		".. data:: Secondary\n"
		"\n"
		"  The mesh should be rendered using the secondary element as color.\n"
		"\n"
		".. data:: Explode\n"
		"\n"
		"  The mesh should be rendered with vertices displaced and coloured by vertex ID.\n"
		"\n"
		".. data:: Meshlet\n"
		"\n"
		"  The mesh should be rendered colorising each meshlet differently.\n"
		"\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__Visualisation_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__Visualisation_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__Visualisation_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_Visualisation,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__Visualisation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__Visualisation_type};

static SwigPyGetSet FillMode___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__FillMode_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"FillMode.__dict__", (void *) &FillMode___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__FillMode_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__FillMode_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__FillMode_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "FillMode",                               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_FillMode_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__FillMode_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__FillMode_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__FillMode_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__FillMode_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The fill mode for polygons.\n"
		"\n"
		".. data:: Solid\n"
		"\n"
		"  Polygons are filled in and rasterized solidly.\n"
		"\n"
		".. data:: Wireframe\n"
		"\n"
		"  Polygons are rendered only with lines along their edges, forming a wireframe.\n"
		"\n"
		".. data:: Point\n"
		"\n"
		"  Only the points at the polygons vertices are rendered.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__FillMode_richcompare,            /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__FillMode_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__FillMode_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_FillMode,            /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__FillMode_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__FillMode_type};

static SwigPyGetSet CullMode___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CullMode_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"CullMode.__dict__", (void *) &CullMode___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__CullMode_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__CullMode_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__CullMode_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "CullMode",                               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_CullMode_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__CullMode_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__CullMode_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__CullMode_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__CullMode_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The culling mode for polygons.\n"
		"\n"
		".. data:: NoCull\n"
		"\n"
		"  No polygon culling is performed.\n"
		"\n"
		".. data:: Front\n"
		"\n"
		"  Front-facing polygons are culled.\n"
		"\n"
		".. data:: Back\n"
		"\n"
		"  Back-facing polygons are culled.\n"
		"\n"
		".. data:: FrontAndBack\n"
		"\n"
		"  Both front-facing and back-facing polygons are culled.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__CullMode_richcompare,            /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__CullMode_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__CullMode_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_CullMode,            /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__CullMode_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CullMode_type};

static SwigPyGetSet ConservativeRaster___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ConservativeRaster_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ConservativeRaster.__dict__", (void *) &ConservativeRaster___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ConservativeRaster_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ConservativeRaster_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ConservativeRaster_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ConservativeRaster",                     /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ConservativeRaster_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ConservativeRaster_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__ConservativeRaster_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__ConservativeRaster_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ConservativeRaster_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The conservative rasterization mode.\n"
		"\n"
		".. data:: Disabled\n"
		"\n"
		"  No conservative rasterization, the default rasterization coverage algorithm is used.\n"
		"\n"
		".. data:: Underestimate\n"
		"\n"
		"  Fragments will only be generated if the primitive full covers all parts of the pixel, including\n"
		"  edges and corners.\n"
		"\n"
		".. data:: Overestimate\n"
		"\n"
		"  Fragments will be generated if the primitive covers any part of the pixel, including edges and\n"
		"  corners.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ConservativeRaster_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ConservativeRaster_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ConservativeRaster_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ConservativeRaster,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ConservativeRaster_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ConservativeRaster_type};

static SwigPyGetSet ShadingRateCombiner___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShadingRateCombiner_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShadingRateCombiner.__dict__", (void *) &ShadingRateCombiner___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShadingRateCombiner_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShadingRateCombiner_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShadingRateCombiner_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ShadingRateCombiner",                    /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShadingRateCombiner_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShadingRateCombiner_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__ShadingRateCombiner_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__ShadingRateCombiner_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShadingRateCombiner_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A combiner to apply when determining a pixel shading rate.\n"
		"\n"
		".. data:: Keep\n"
		"\n"
		"  Keep the first input to the combiner.\n"
		"\n"
		".. data:: Passthrough\n"
		"\n"
		"  Keep the first input to the combiner. Alias for :data:`Keep`, for D3D terminology.\n"
		"\n"
		".. data:: Replace\n"
		"\n"
		"  Replace with the second input to the combiner.\n"
		"\n"
		".. data:: Override\n"
		"\n"
		"  Replace with the second input to the combiner. Alias for :data:`Replace`, for D3D terminology.\n"
		"\n"
		".. data:: Min\n"
		"\n"
		"  Use the minimum (finest rate) of the two inputs.\n"
		"\n"
		".. data:: Max\n"
		"\n"
		"  Use the maximum (coarsest rate) of the two inputs.\n"
		"\n"
		".. data:: Multiply\n"
		"\n"
		"  Multiply the two rates together (e.g. 1x1 and 1x2 = 1x2, 2x2 and 2x2 = 4x4). Note that D3D names\n"
		"  this 'sum' misleadingly.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShadingRateCombiner_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShadingRateCombiner_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShadingRateCombiner_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShadingRateCombiner, /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShadingRateCombiner_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShadingRateCombiner_type};

static SwigPyGetSet LineRaster___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__LineRaster_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"LineRaster.__dict__", (void *) &LineRaster___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__LineRaster_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__LineRaster_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__LineRaster_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "LineRaster",                             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_LineRaster_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__LineRaster_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__LineRaster_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__LineRaster_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__LineRaster_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The line rasterization mode.\n"
		"\n"
		".. data:: Default\n"
		"\n"
		"  Default line rasterization mode as defined by the API specification.\n"
		"\n"
		".. data:: Rectangular\n"
		"\n"
		"  Lines are rasterized as rectangles extruded from the line.\n"
		"\n"
		".. data:: Bresenham\n"
		"\n"
		"  Lines are rasterized according to the bresenham line algorithm.\n"
		"\n"
		".. data:: RectangularSmooth\n"
		"\n"
		"  Lines are rasterized as rectangles extruded from the line with coverage falloff being\n"
		"  implementation independent.\n"
		"\n"
		".. data:: RectangularD3D\n"
		"\n"
		"  Lines are rasterized as rectangles extruded from the line, but with a width of 1.4 according to\n"
		"  legacy D3D behaviour\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__LineRaster_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__LineRaster_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__LineRaster_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_LineRaster,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__LineRaster_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__LineRaster_type};

static SwigPyGetSet FilterMode___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__FilterMode_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"FilterMode.__dict__", (void *) &FilterMode___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__FilterMode_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__FilterMode_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__FilterMode_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "FilterMode",                             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_FilterMode_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__FilterMode_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__FilterMode_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__FilterMode_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__FilterMode_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The texture filtering mode for a given direction (minification, magnification, or\n"
		"between mips).\n"
		"\n"
		".. data:: NoFilter\n"
		"\n"
		"  No filtering - this direction is disabled or there is no sampler.\n"
		"\n"
		".. data:: Point\n"
		"\n"
		"  Point or nearest filtering - the closest pixel or mip level to the sample location is used.\n"
		"\n"
		".. data:: Linear\n"
		"\n"
		"  Linear filtering - a linear interpolation happens between the pixels or mips on either side of the\n"
		"  sample location in each direction.\n"
		"\n"
		".. data:: Cubic\n"
		"\n"
		"  Similar to linear filtering but with a cubic curve used for interpolation instead of linear.\n"
		"\n"
		".. data:: Anisotropic\n"
		"\n"
		"  This sampler is using anisotropic filtering.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__FilterMode_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__FilterMode_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__FilterMode_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_FilterMode,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__FilterMode_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__FilterMode_type};

static SwigPyGetSet FilterFunction___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__FilterFunction_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"FilterFunction.__dict__", (void *) &FilterFunction___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__FilterFunction_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__FilterFunction_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__FilterFunction_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "FilterFunction",                         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_FilterFunction_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__FilterFunction_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__FilterFunction_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__FilterFunction_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__FilterFunction_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The function used to process the returned value after interpolation.\n"
		"\n"
		".. data:: Normal\n"
		"\n"
		"  No special processing is used, the value is returned directly to the shader.\n"
		"\n"
		".. data:: Comparison\n"
		"\n"
		"  The value from interpolation is compared to a reference value and the comparison result is\n"
		"  returned to the shader.\n"
		"\n"
		".. data:: Minimum\n"
		"\n"
		"  Instead of interpolating between sample points to retrieve an interpolated value, a min filter is\n"
		"  used instead to find the minimum sample value.\n"
		"\n"
		"  Texels that were weight to 0 during interpolation are not included in the min function.\n"
		"\n"
		".. data:: Maximum\n"
		"\n"
		"  Instead of interpolating between sample points to retrieve an interpolated value, a max filter is\n"
		"  used instead to find the maximum sample value.\n"
		"\n"
		"  Texels that were weight to 0 during interpolation are not included in the max function.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__FilterFunction_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__FilterFunction_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__FilterFunction_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_FilterFunction,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__FilterFunction_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__FilterFunction_type};

static SwigPyGetSet CompareFunction___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CompareFunction_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"CompareFunction.__dict__", (void *) &CompareFunction___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__CompareFunction_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__CompareFunction_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__CompareFunction_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "CompareFunction",                        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_CompareFunction_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__CompareFunction_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__CompareFunction_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__CompareFunction_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__CompareFunction_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A comparison function to return a ``bool`` result from two inputs ``A`` and ``B``.\n"
		"\n"
		".. data:: Never\n"
		"\n"
		"  ``False``\n"
		"\n"
		".. data:: AlwaysTrue\n"
		"\n"
		"  ``True``\n"
		"\n"
		".. data:: Less\n"
		"\n"
		"  ``A < B``\n"
		"\n"
		".. data:: LessEqual\n"
		"\n"
		"  ``A <= B``\n"
		"\n"
		".. data:: Greater\n"
		"\n"
		"  ``A > B``\n"
		"\n"
		".. data:: GreaterEqual\n"
		"\n"
		"  ``A >= B``\n"
		"\n"
		".. data:: Equal\n"
		"\n"
		"  ``A == B``\n"
		"\n"
		".. data:: NotEqual\n"
		"\n"
		"  ``A != B``\n"
		"\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__CompareFunction_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__CompareFunction_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__CompareFunction_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_CompareFunction,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__CompareFunction_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CompareFunction_type};

static SwigPyGetSet StencilOperation___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__StencilOperation_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"StencilOperation.__dict__", (void *) &StencilOperation___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__StencilOperation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__StencilOperation_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__StencilOperation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "StencilOperation",                       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_StencilOperation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__StencilOperation_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__StencilOperation_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__StencilOperation_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__StencilOperation_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A stencil operation to apply in stencil processing.\n"
		"\n"
		".. data:: Keep\n"
		"\n"
		"  Keep the existing value unmodified.\n"
		"\n"
		".. data:: Zero\n"
		"\n"
		"  Set the value to ``0``.\n"
		"\n"
		".. data:: Replace\n"
		"\n"
		"  Replace the value with the stencil reference value.\n"
		"\n"
		".. data:: IncSat\n"
		"\n"
		"  Increment the value but saturate at the maximum representable value (typically ``255``).\n"
		"\n"
		".. data:: DecSat\n"
		"\n"
		"  Decrement the value but saturate at ``0``.\n"
		"\n"
		".. data:: IncWrap\n"
		"\n"
		"  Increment the value and wrap at the maximum representable value (typically ``255``) to ``0``.\n"
		"\n"
		".. data:: DecWrap\n"
		"\n"
		"  Decrement the value and wrap at ``0`` to the maximum representable value (typically ``255``).\n"
		"\n"
		".. data:: Invert\n"
		"\n"
		"  Invert the bits in the stencil value (bitwise ``NOT``).\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__StencilOperation_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__StencilOperation_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__StencilOperation_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_StencilOperation,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__StencilOperation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__StencilOperation_type};

static SwigPyGetSet BlendMultiplier___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__BlendMultiplier_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"BlendMultiplier.__dict__", (void *) &BlendMultiplier___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__BlendMultiplier_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__BlendMultiplier_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__BlendMultiplier_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "BlendMultiplier",                        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_BlendMultiplier_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__BlendMultiplier_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__BlendMultiplier_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__BlendMultiplier_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__BlendMultiplier_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A multiplier on one component in the blend equation.\n"
		"\n"
		".. note:: The \"source\" value is the value written out by the shader.\n"
		"\n"
		"  The \"second source\" value is provided when dual source blending is used.\n"
		"\n"
		"  The \"destination\" value is the value in the target being blended to.\n"
		"\n"
		"  These values are combined using a given blend operation, see :class:`BlendOperation`.\n"
		"\n"
		"  Where a color is referenced, the value depends on where the multiplier appears in the blend\n"
		"  equation. If it is a multiplier on the color component then it refers to the color component. If\n"
		"  it is a multiplier on the alpha component then it refers to the alpha component.\n"
		"\n"
		"  If alpha is referenced explicitly it always refers to alpha, in both color and alpha equations.\n"
		"\n"
		".. data:: Zero\n"
		"\n"
		"  The literal value ``0.0``.\n"
		"\n"
		".. data:: One\n"
		"\n"
		"  The literal value ``1.0``.\n"
		"\n"
		".. data:: SrcCol\n"
		"\n"
		"  The source value's color.\n"
		"\n"
		".. data:: InvSrcCol\n"
		"\n"
		"  ``1.0`` minus the source value's color.\n"
		"\n"
		".. data:: DstCol\n"
		"\n"
		"  The destination value's color.\n"
		"\n"
		".. data:: InvDstCol\n"
		"\n"
		"  ``1.0`` minus the destination value's color.\n"
		"\n"
		".. data:: SrcAlpha\n"
		"\n"
		"  The source value's alpha.\n"
		"\n"
		".. data:: InvSrcAlpha\n"
		"\n"
		"  ``1.0`` minus the source value's alpha.\n"
		"\n"
		".. data:: DstAlpha\n"
		"\n"
		"  The destination value's alpha.\n"
		"\n"
		".. data:: InvDstAlpha\n"
		"\n"
		"  ``1.0`` minus the destination value's alpha.\n"
		"\n"
		".. data:: SrcAlphaSat\n"
		"\n"
		"  The lowest value of :data:`SrcAlpha` and :data:`InvDstAlpha`. If used in the alpha equation, it takes the value :data:`One`.\n"
		"\n"
		".. data:: FactorRGB\n"
		"\n"
		"  The color components of the fixed blend factor constant.\n"
		"\n"
		".. data:: InvFactorRGB\n"
		"\n"
		"  ``1.0`` minus the color components of the fixed blend factor constant.\n"
		"\n"
		".. data:: FactorAlpha\n"
		"\n"
		"  The alpha component of the fixed blend factor constant.\n"
		"\n"
		".. data:: InvFactorAlpha\n"
		"\n"
		"  ``1.0`` minus the alpha components of the fixed blend factor constant.\n"
		"\n"
		".. data:: Src1Col\n"
		"\n"
		"  The second source value's color.\n"
		"\n"
		".. data:: InvSrc1Col\n"
		"\n"
		"  ``1.0`` minus the second source value's color.\n"
		"\n"
		".. data:: Src1Alpha\n"
		"\n"
		"  The second source value's alpha.\n"
		"\n"
		".. data:: InvSrc1Alpha\n"
		"\n"
		"  ``1.0`` minus the second source value's alpha.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__BlendMultiplier_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__BlendMultiplier_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__BlendMultiplier_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_BlendMultiplier,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__BlendMultiplier_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__BlendMultiplier_type};

static SwigPyGetSet BlendOperation___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__BlendOperation_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"BlendOperation.__dict__", (void *) &BlendOperation___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__BlendOperation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__BlendOperation_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__BlendOperation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "BlendOperation",                         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_BlendOperation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__BlendOperation_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__BlendOperation_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__BlendOperation_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__BlendOperation_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A blending operation to apply in color blending.\n"
		"\n"
		".. note:: The \"source\" value is the value written out by the shader.\n"
		"\n"
		"  The \"destination\" value is the value in the target being blended to.\n"
		"\n"
		"  These values are multiplied by a given blend factor, see :class:`BlendMultiplier`.\n"
		"\n"
		".. data:: Add\n"
		"\n"
		"  Add the two values being processed together.\n"
		"\n"
		".. data:: Subtract\n"
		"\n"
		"  Subtract the destination value from the source value.\n"
		"\n"
		".. data:: ReversedSubtract\n"
		"\n"
		"  Subtract the source value from the destination value.\n"
		"\n"
		".. data:: Minimum\n"
		"\n"
		"  The minimum of the source and destination value.\n"
		"\n"
		".. data:: Maximum\n"
		"\n"
		"  The maximum of the source and destination value.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__BlendOperation_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__BlendOperation_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__BlendOperation_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_BlendOperation,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__BlendOperation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__BlendOperation_type};

static SwigPyGetSet LogicOperation___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__LogicOperation_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"LogicOperation.__dict__", (void *) &LogicOperation___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__LogicOperation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__LogicOperation_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__LogicOperation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "LogicOperation",                         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_LogicOperation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__LogicOperation_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__LogicOperation_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__LogicOperation_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__LogicOperation_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A logical operation to apply when writing texture values to an output.\n"
		"\n"
		".. note:: The \"source\" value is the value written out by the shader.\n"
		"\n"
		"  The \"destination\" value is the value in the target being written to.\n"
		"\n"
		".. data:: NoOp\n"
		"\n"
		"  No operation is performed, the destination is unmodified.\n"
		"\n"
		".. data:: Clear\n"
		"\n"
		"  A ``0`` in every bit.\n"
		"\n"
		".. data:: Set\n"
		"\n"
		"  A ``1`` in every bit.\n"
		"\n"
		".. data:: Copy\n"
		"\n"
		"  The contents of the source value.\n"
		"\n"
		".. data:: CopyInverted\n"
		"\n"
		"  The contents of the source value are bitwise inverted.\n"
		"\n"
		".. data:: Invert\n"
		"\n"
		"  The contents of the destination value are bitwise inverted, then written.\n"
		"\n"
		".. data:: And\n"
		"\n"
		"  The source and destination values are combined with the bitwise ``AND`` operator.\n"
		"\n"
		".. data:: Nand\n"
		"\n"
		"  The source and destination values are combined with the bitwise ``NAND`` operator.\n"
		"\n"
		".. data:: Or\n"
		"\n"
		"  The source and destination values are combined with the bitwise ``OR`` operator.\n"
		"\n"
		".. data:: Xor\n"
		"\n"
		"  The source and destination values are combined with the bitwise ``XOR`` operator.\n"
		"\n"
		".. data:: Nor\n"
		"\n"
		"  The source and destination values are combined with the bitwise ``NOR`` operator.\n"
		"\n"
		".. data:: Equivalent\n"
		"\n"
		"  The source and destination values are combined with the logical equivalence operator, defined as\n"
		"  ``NOT (s XOR d)``.\n"
		"\n"
		".. data:: AndReverse\n"
		"\n"
		"  The source and inverted destination values are combined with the bitwise ``AND`` operator - i.e.\n"
		"  ``s AND (NOT d)``.\n"
		"\n"
		".. data:: AndInverted\n"
		"\n"
		"  The inverted source and destination values are combined with the bitwise ``AND`` operator - i.e.\n"
		"  ``(NOT s) AND d``.\n"
		"\n"
		".. data:: OrReverse\n"
		"\n"
		"  The source and inverted destination values are combined with the bitwise ``OR`` operator - i.e.\n"
		"  ``s OR (NOT d)``.\n"
		"\n"
		".. data:: OrInverted\n"
		"\n"
		"  The inverted source and destination values are combined with the bitwise ``OR`` operator - i.e.\n"
		"  ``(NOT s) OR d``.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__LogicOperation_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__LogicOperation_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__LogicOperation_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_LogicOperation,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__LogicOperation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__LogicOperation_type};

static SwigPyGetSet GPUCounter___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__GPUCounter_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"GPUCounter.__dict__", (void *) &GPUCounter___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__GPUCounter_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__GPUCounter_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__GPUCounter_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "GPUCounter",                             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_GPUCounter_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__GPUCounter_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__GPUCounter_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__GPUCounter_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__GPUCounter_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Pre-defined GPU counters that can be supported by a given implementation.\n"
		"\n"
		"GPU counters actually available can be queried by :meth:`ReplayController.EnumerateCounters`. If any\n"
		"in this list are supported they will be returned with these counter IDs. More counters may be\n"
		"enumerated with IDs in the appropriate ranges.\n"
		"\n"
		".. data:: EventGPUDuration\n"
		"\n"
		"  Time taken for this event on the GPU, as measured by delta between two GPU timestamps.\n"
		"\n"
		".. data:: InputVerticesRead\n"
		"\n"
		"  Number of vertices read by input assembler.\n"
		"\n"
		".. data:: IAPrimitives\n"
		"\n"
		"  Number of primitives read by the input assembler.\n"
		"\n"
		".. data:: GSPrimitives\n"
		"\n"
		"  Number of primitives output by a geometry shader.\n"
		"\n"
		".. data:: RasterizerInvocations\n"
		"\n"
		"  Number of primitives that were sent to the rasterizer.\n"
		"\n"
		".. data:: RasterizedPrimitives\n"
		"\n"
		"  Number of primitives that were rendered.\n"
		"\n"
		".. data:: SamplesPassed\n"
		"\n"
		"  Number of samples that passed depth/stencil test.\n"
		"\n"
		".. data:: VSInvocations\n"
		"\n"
		"  Number of times a :data:`vertex shader <ShaderStage.Vertex>` was invoked.\n"
		"\n"
		".. data:: HSInvocations\n"
		"\n"
		"  Number of times a :data:`hull shader <ShaderStage.Hull>` was invoked.\n"
		"\n"
		".. data:: TCSInvocations\n"
		"\n"
		"  Number of times a :data:`tessellation control shader <ShaderStage.Tess_Control>` was invoked.\n"
		"\n"
		".. data:: DSInvocations\n"
		"\n"
		"  Number of times a :data:`domain shader <ShaderStage.Domain>` was invoked.\n"
		"\n"
		".. data:: TESInvocations\n"
		"\n"
		"  Number of times a :data:`tessellation evaluation shader <ShaderStage.Tess_Eval>` was invoked.\n"
		"\n"
		".. data:: GSInvocations\n"
		"\n"
		"  Number of times a :data:`domain shader <ShaderStage.Domain>` was invoked.\n"
		"\n"
		".. data:: PSInvocations\n"
		"\n"
		"  Number of times a :data:`pixel shader <ShaderStage.Pixel>` was invoked.\n"
		"\n"
		".. data:: FSInvocations\n"
		"\n"
		"  Number of times a :data:`fragment shader <ShaderStage.Fragment>` was invoked.\n"
		"\n"
		".. data:: CSInvocations\n"
		"\n"
		"  Number of times a :data:`compute shader <ShaderStage.Compute>` was invoked.\n"
		"\n"
		".. data:: TSInvocations\n"
		"\n"
		"  Number of times a :data:`task shader <ShaderStage.Task>` was invoked.\n"
		"\n"
		".. data:: ASInvocations\n"
		"\n"
		"  Number of times a :data:`amplification shader <ShaderStage.Amplification>` was invoked.\n"
		"\n"
		".. data:: MSInvocations\n"
		"\n"
		"  Number of times a :data:`mesh shader <ShaderStage.Mesh>` was invoked.\n"
		"\n"
		".. data:: FirstAMD\n"
		"\n"
		"  The AMD-specific counter IDs start from this value.\n"
		"\n"
		".. data:: LastAMD\n"
		"\n"
		"  The AMD-specific counter IDs end with this value.\n"
		"\n"
		".. data:: FirstIntel\n"
		"\n"
		"  The Intel-specific counter IDs start from this value.\n"
		"\n"
		".. data:: LastIntel\n"
		"\n"
		"  The Intel-specific counter IDs end with this value.\n"
		"\n"
		".. data:: FirstNvidia\n"
		"\n"
		"  The nVidia-specific counter IDs start from this value.\n"
		"\n"
		".. data:: LastNvidia\n"
		"\n"
		"  The nVidia-specific counter IDs end with this value.\n"
		"\n"
		".. data:: FirstVulkanExtended\n"
		"\n"
		"  The Vulkan extended counter IDs start from this value.\n"
		"\n"
		".. data:: LastVulkanExtended\n"
		"\n"
		"  The Vulkan extended counter IDs end with this value.\n"
		"\n"
		".. data:: FirstARM\n"
		"\n"
		"  The ARM-specific counter IDs start from this value.\n"
		"\n"
		".. data:: LastARM\n"
		"\n"
		"  The ARM-specific counter IDs end with this value.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__GPUCounter_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__GPUCounter_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__GPUCounter_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_GPUCounter,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__GPUCounter_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__GPUCounter_type};

static SwigPyGetSet CounterUnit___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CounterUnit_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"CounterUnit.__dict__", (void *) &CounterUnit___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__CounterUnit_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__CounterUnit_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__CounterUnit_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "CounterUnit",                            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_CounterUnit_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__CounterUnit_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__CounterUnit_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__CounterUnit_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__CounterUnit_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The unit that GPU counter data is returned in.\n"
		"\n"
		".. data:: Absolute\n"
		"\n"
		"  The value is an absolute value and should be interpreted as unitless.\n"
		"\n"
		".. data:: Seconds\n"
		"\n"
		"  The value is a duration in seconds.\n"
		"\n"
		".. data:: Percentage\n"
		"\n"
		"  The value is a floating point percentage value between 0.0 and 1.0.\n"
		"\n"
		".. data:: Ratio\n"
		"\n"
		"  The value describes a ratio between two separate GPU units or counters.\n"
		"\n"
		".. data:: Bytes\n"
		"\n"
		"  The value is in bytes.\n"
		"\n"
		".. data:: Cycles\n"
		"\n"
		"  The value is a duration in clock cycles.\n"
		"\n"
		".. data:: Hertz\n"
		"\n"
		"  The value is a value in Hertz (cycles per second).\n"
		"\n"
		".. data:: Volt\n"
		"\n"
		"  The value is a value in Volts.\n"
		"\n"
		".. data:: Celsius\n"
		"\n"
		"  The value is a value in Celsius.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__CounterUnit_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__CounterUnit_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__CounterUnit_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_CounterUnit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__CounterUnit_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CounterUnit_type};

static SwigPyGetSet CameraType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__CameraType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"CameraType.__dict__", (void *) &CameraType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__CameraType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__CameraType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__CameraType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "CameraType",                             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_CameraType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__CameraType_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__CameraType_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__CameraType_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__CameraType_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The type of camera controls for an :class:`Camera`.\n"
		"\n"
		".. data:: Arcball\n"
		"\n"
		"  Arcball controls that rotate and zoom around the origin point.\n"
		"\n"
		".. data:: FPSLook\n"
		"\n"
		"  Traditional FPS style controls with movement in each axis relative to the current look direction.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__CameraType_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__CameraType_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__CameraType_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_CameraType,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__CameraType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__CameraType_type};

static SwigPyGetSet ReplaySupport___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ReplaySupport_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ReplaySupport.__dict__", (void *) &ReplaySupport___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ReplaySupport_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ReplaySupport_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ReplaySupport_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ReplaySupport",                          /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ReplaySupport_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ReplaySupport_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__ReplaySupport_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__ReplaySupport_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ReplaySupport_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"How supported a given API is on a particular replay instance.\n"
		"\n"
		".. data:: Unsupported\n"
		"\n"
		"  The API is not supported.\n"
		"\n"
		".. data:: Supported\n"
		"\n"
		"  The API is fully supported.\n"
		"\n"
		".. data:: SuggestRemote\n"
		"\n"
		"  The API is supported locally but the capture indicates it was made on a different type of machine\n"
		"  so remote replay might be desired.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ReplaySupport_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ReplaySupport_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ReplaySupport_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ReplaySupport,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ReplaySupport_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ReplaySupport_type};

static SwigPyGetSet ResultCode___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ResultCode_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ResultCode.__dict__", (void *) &ResultCode___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ResultCode_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ResultCode_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ResultCode_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ResultCode",                             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ResultCode_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ResultCode_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__ResultCode_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__ResultCode_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ResultCode_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The result from a replay operation such as opening a capture or connecting to\n"
		"a remote server.\n"
		"\n"
		".. data:: Succeeded\n"
		"\n"
		"  The operation succeeded.\n"
		"\n"
		".. data:: UnknownError\n"
		"\n"
		"  An unknown error occurred.\n"
		"\n"
		".. data:: InternalError\n"
		"\n"
		"  An internal error occurred indicating a bug or unexpected condition.\n"
		"\n"
		".. data:: FileNotFound\n"
		"\n"
		"  The specified file was not found.\n"
		"\n"
		".. data:: InjectionFailed\n"
		"\n"
		"  Injection or hooking into the target process failed.\n"
		"\n"
		".. data:: IncompatibleProcess\n"
		"\n"
		"  An incompatible process was found, e.g. a 32-bit process with 32-bit support not available.\n"
		"\n"
		".. data:: NetworkIOFailed\n"
		"\n"
		"  A network I/O operation failed.\n"
		"\n"
		".. data:: NetworkRemoteBusy\n"
		"\n"
		"  The remote side of the network connection was busy.\n"
		"\n"
		".. data:: NetworkVersionMismatch\n"
		"\n"
		"  The other side of the network connection was not at a compatible version.\n"
		"\n"
		".. data:: FileIOFailed\n"
		"\n"
		"  A filesystem I/O operation failed.\n"
		"\n"
		".. data:: FileIncompatibleVersion\n"
		"\n"
		"  The capture file had an incompatible version.\n"
		"\n"
		".. data:: FileCorrupted\n"
		"\n"
		"  The capture file is corrupted or otherwise unrecognisable.\n"
		"\n"
		".. data:: FileUnrecognised\n"
		"\n"
		"  The file was not recognised as any supported file type.\n"
		"\n"
		".. data:: ImageUnsupported\n"
		"\n"
		"  The image file or format is unrecognised or not supported in this form.\n"
		"\n"
		".. data:: APIUnsupported\n"
		"\n"
		"  The API used in the capture is not supported.\n"
		"\n"
		".. data:: APIInitFailed\n"
		"\n"
		"  The API used in the capture failed to initialise.\n"
		"\n"
		".. data:: APIIncompatibleVersion\n"
		"\n"
		"  The API data in the capture had an incompatible version.\n"
		"\n"
		".. data:: APIHardwareUnsupported\n"
		"\n"
		"  Current replaying hardware unsupported or incompatible with captured hardware.\n"
		"\n"
		".. data:: APIDataCorrupted\n"
		"\n"
		"  While loading the capture for replay, the driver encountered corrupted or invalid serialised data.\n"
		"\n"
		".. data:: APIReplayFailed\n"
		"\n"
		"  The API failed to replay the capture, with some runtime error that couldn't be determined until\n"
		"  the replay began.\n"
		"\n"
		".. data:: JDWPFailure\n"
		"\n"
		"  Use of JDWP to launch and inject into the application failed, this most often indicates that some\n"
		"  other JDWP-using program such as Android Studio is interfering.\n"
		"\n"
		".. data:: AndroidGrantPermissionsFailed\n"
		"\n"
		"  Failed to grant runtime permissions when installing Android remote server.\n"
		"\n"
		".. data:: AndroidABINotFound\n"
		"\n"
		"  Couldn't determine supported ABIs when installing Android remote server.\n"
		"\n"
		".. data:: AndroidAPKFolderNotFound\n"
		"\n"
		"  Couldn't find the folder which contains the Android remote server APK.\n"
		"\n"
		".. data:: AndroidAPKInstallFailed\n"
		"\n"
		"  Failed to install Android remote server for unknown reasons.\n"
		"\n"
		".. data:: AndroidAPKVerifyFailed\n"
		"\n"
		"  Failed to install Android remote server.\n"
		"\n"
		".. data:: RemoteServerConnectionLost\n"
		"\n"
		"  While replaying on a remote server, the connection was lost.\n"
		"\n"
		".. data:: OutOfMemory\n"
		"\n"
		"  An out of memory error was encountered.\n"
		"\n"
		".. data:: DeviceLost\n"
		"\n"
		"  A device lost fatal error was encountered.\n"
		"\n"
		".. data:: DataNotAvailable\n"
		"\n"
		"  Data was requested through RenderDoc's API which is not available.\n"
		"\n"
		".. data:: InvalidParameter\n"
		"\n"
		"  An invalid parameter was passed to RenderDoc's API.\n"
		"\n"
		".. data:: CompressionFailed\n"
		"\n"
		"  Compression or decompression failed.\n"
		"\n"
		".. data:: AndroidLayerConfFailed\n"
		"\n"
		"  Debug layer configuration failed on Android.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ResultCode_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ResultCode_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ResultCode_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ResultCode,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ResultCode_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ResultCode_type};

static SwigPyGetSet TargetControlMessageType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TargetControlMessageType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TargetControlMessageType.__dict__", (void *) &TargetControlMessageType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TargetControlMessageType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TargetControlMessageType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TargetControlMessageType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "TargetControlMessageType",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TargetControlMessageType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TargetControlMessageType_type.as_number,      /* tp_as_number */
    &SwigPyBuiltin__TargetControlMessageType_type.as_sequence,    /* tp_as_sequence */
    &SwigPyBuiltin__TargetControlMessageType_type.as_mapping,     /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TargetControlMessageType_type.as_buffer,      /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The type of message received from or sent to an application target control connection.\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  No message or an unknown message type.\n"
		"\n"
		".. data:: Disconnected\n"
		"\n"
		"  The other end of the connection disconnected.\n"
		"\n"
		".. data:: Busy\n"
		"\n"
		"  The other end of the connection was busy.\n"
		"\n"
		".. data:: Noop\n"
		"\n"
		"  Nothing happened, the connection is being kept alive.\n"
		"\n"
		".. data:: NewCapture\n"
		"\n"
		"  A new capture was made.\n"
		"\n"
		".. data:: CaptureCopied\n"
		"\n"
		"  A capture was successfully copied across the connection.\n"
		"\n"
		".. data:: RegisterAPI\n"
		"\n"
		"  The target has initialised a graphics API.\n"
		"\n"
		".. data:: NewChild\n"
		"\n"
		"  The target has created a child process.\n"
		"\n"
		".. data:: CaptureProgress\n"
		"\n"
		"  Progress update on an on-going frame capture.\n"
		"\n"
		".. data:: CapturableWindowCount\n"
		"\n"
		"  The number of capturable windows has changed.\n"
		"\n"
		".. data:: RequestShow\n"
		"\n"
		"  The client has requested that the controller show itself (raise its window to the top).\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TargetControlMessageType_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TargetControlMessageType_methods,              /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TargetControlMessageType_getset,               /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TargetControlMessageType,                /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TargetControlMessageType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TargetControlMessageType_type};

static SwigPyGetSet EnvMod___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__EnvMod_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"EnvMod.__dict__", (void *) &EnvMod___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__EnvMod_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__EnvMod_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__EnvMod_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "EnvMod",                                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_EnvMod_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__EnvMod_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__EnvMod_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__EnvMod_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__EnvMod_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"How to modify an environment variable.\n"
		"\n"
		".. data:: Set\n"
		"\n"
		"  Set the variable to the given value.\n"
		"\n"
		".. data:: Append\n"
		"\n"
		"  Add the given value to the end of the variable, using the separator.\n"
		"\n"
		".. data:: Prepend\n"
		"\n"
		"  Add the given value to the start of the variable, using the separator.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__EnvMod_richcompare,              /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__EnvMod_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__EnvMod_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_EnvMod,              /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__EnvMod_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__EnvMod_type};

static SwigPyGetSet EnvSep___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__EnvSep_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"EnvSep.__dict__", (void *) &EnvSep___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__EnvSep_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__EnvSep_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__EnvSep_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "EnvSep",                                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_EnvSep_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__EnvSep_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__EnvSep_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__EnvSep_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__EnvSep_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The separator to use if needed when modifying an environment variable.\n"
		"\n"
		".. data:: Platform\n"
		"\n"
		"  Use the character appropriate for separating items on the platform.\n"
		"\n"
		"  On Windows this means the semi-colon ``;`` character will be used, on posix systems the colon\n"
		"  ``:`` character will be used.\n"
		"\n"
		".. data:: SemiColon\n"
		"\n"
		"  Use a semi-colon ``;`` character.\n"
		"\n"
		".. data:: Colon\n"
		"\n"
		"  Use a colon ``:`` character.\n"
		"\n"
		".. data:: NoSep\n"
		"\n"
		"  No separator will be used.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__EnvSep_richcompare,              /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__EnvSep_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__EnvSep_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_EnvSep,              /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__EnvSep_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__EnvSep_type};

static SwigPyGetSet LogType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__LogType_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"LogType.__dict__", (void *) &LogType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__LogType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__LogType_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__LogType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "LogType",                                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_LogType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__LogType_type.as_number,   /* tp_as_number */
    &SwigPyBuiltin__LogType_type.as_sequence, /* tp_as_sequence */
    &SwigPyBuiltin__LogType_type.as_mapping,  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__LogType_type.as_buffer,   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The type of a log message\n"
		"\n"
		".. data:: Debug\n"
		"\n"
		"  The log message is a verbose debug-only message that can be discarded in release builds.\n"
		"\n"
		".. data:: Comment\n"
		"\n"
		"  The log message is informational.\n"
		"\n"
		".. data:: Warning\n"
		"\n"
		"  The log message describes a warning that could indicate a problem or be useful in diagnostics.\n"
		"\n"
		".. data:: Error\n"
		"\n"
		"  The log message indicates an error was encountered.\n"
		"\n"
		".. data:: Fatal\n"
		"\n"
		"  The log message indicates a fatal error occurred which is impossible to recover from.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__LogType_richcompare,             /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__LogType_methods,           /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__LogType_getset,            /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_LogType,             /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__LogType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__LogType_type};

static SwigPyGetSet ReplayOptimisationLevel___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ReplayOptimisationLevel_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ReplayOptimisationLevel.__dict__", (void *) &ReplayOptimisationLevel___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ReplayOptimisationLevel_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ReplayOptimisationLevel_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ReplayOptimisationLevel_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ReplayOptimisationLevel",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ReplayOptimisationLevel_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ReplayOptimisationLevel_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__ReplayOptimisationLevel_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__ReplayOptimisationLevel_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ReplayOptimisationLevel_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The level of optimisation used in\n"
		"\n"
		".. data:: NoOptimisation\n"
		"\n"
		"  Completely disabled, no optimisation will be used at all.\n"
		"\n"
		".. data:: Conservative\n"
		"\n"
		"  Optimisation is used when it doesn't interfere with replay correctness.\n"
		"\n"
		".. data:: Balanced\n"
		"\n"
		"  Optimisation is used when it has minimal impact on replay correctness. This could include e.g.\n"
		"  resources appearing cleared instead of containing contents from prior frames where those resources\n"
		"  are written to before being read.\n"
		"\n"
		".. data:: Fastest\n"
		"\n"
		"  All possible optimisations are enabled as long as they do not cause invalid/incorrect replay.\n"
		"  This could result in side-effects like data from one replay being visible early in another replay,\n"
		"  if it's known that the data will be overwritten before being used.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ReplayOptimisationLevel_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ReplayOptimisationLevel_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ReplayOptimisationLevel_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ReplayOptimisationLevel,                 /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ReplayOptimisationLevel_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ReplayOptimisationLevel_type};

static SwigPyGetSet WindowingSystem___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__WindowingSystem_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"WindowingSystem.__dict__", (void *) &WindowingSystem___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__WindowingSystem_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__WindowingSystem_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__WindowingSystem_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "WindowingSystem",                        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_WindowingSystem_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__WindowingSystem_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__WindowingSystem_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__WindowingSystem_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__WindowingSystem_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Specifies a windowing system to use for creating an output window.\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  Unknown window type, no windowing data is passed and no native window is described.\n"
		"\n"
		".. data:: Headless\n"
		"\n"
		"  The windowing data doesn't describe a real window but a virtual area, allowing all normal output\n"
		"  rendering to happen off-screen.\n"
		"  See :func:`CreateHeadlessWindowingData`.\n"
		"\n"
		".. data:: Win32\n"
		"\n"
		"  The windowing data refers to a Win32 window. See :func:`CreateWin32WindowingData`.\n"
		"\n"
		".. data:: Xlib\n"
		"\n"
		"  The windowing data refers to an Xlib window. See :func:`CreateXLibWindowingData`.\n"
		"\n"
		".. data:: XCB\n"
		"\n"
		"  The windowing data refers to an XCB window. See :func:`CreateXCBWindowingData`.\n"
		"\n"
		".. data:: Android\n"
		"\n"
		"  The windowing data refers to an Android window. See :func:`CreateAndroidWindowingData`.\n"
		"\n"
		".. data:: MacOS\n"
		"\n"
		"  The windowing data refers to a MacOS / OS X NSView & CALayer that is Metal/GL compatible.\n"
		"  See :func:`CreateMacOSWindowingData`.\n"
		"\n"
		".. data:: Wayland\n"
		"\n"
		"  The windowing data refers to an Wayland window. See :func:`CreateWaylandWindowingData`.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__WindowingSystem_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__WindowingSystem_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__WindowingSystem_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_WindowingSystem,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__WindowingSystem_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__WindowingSystem_type};

static SwigPyGetSet PathProperty___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__PathProperty_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"PathProperty.__dict__", (void *) &PathProperty___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__PathProperty_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__PathProperty_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__PathProperty_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "PathProperty",                           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_PathProperty_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__PathProperty_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__PathProperty_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__PathProperty_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__PathProperty_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A set of flags describing the properties of a path on a remote filesystem.\n"
		"\n"
		".. data:: NoFlags\n"
		"\n"
		"  No special file properties.\n"
		"\n"
		".. data:: Directory\n"
		"\n"
		"  This file is a directory or folder.\n"
		"\n"
		".. data:: Hidden\n"
		"\n"
		"  This file is considered hidden by the filesystem.\n"
		"\n"
		".. data:: Executable\n"
		"\n"
		"  This file has been identified as an executable program or script.\n"
		"\n"
		".. data:: ErrorUnknown\n"
		"\n"
		"  A special flag indicating that a query for this file failed, but for unknown reasons.\n"
		"\n"
		".. data:: ErrorAccessDenied\n"
		"\n"
		"  A special flag indicating that a query for this file failed because access to the path was\n"
		"  denied.\n"
		"\n"
		".. data:: ErrorInvalidPath\n"
		"\n"
		"  A special flag indicating that a query for this file failed because the path was invalid.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__PathProperty_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__PathProperty_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__PathProperty_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_PathProperty,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__PathProperty_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__PathProperty_type};

static SwigPyGetSet SectionFlags___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SectionFlags_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SectionFlags.__dict__", (void *) &SectionFlags___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SectionFlags_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SectionFlags_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SectionFlags_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "SectionFlags",                           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_SectionFlags_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SectionFlags_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__SectionFlags_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__SectionFlags_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SectionFlags_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A set of flags describing the properties of a section in a renderdoc capture.\n"
		"\n"
		".. data:: NoFlags\n"
		"\n"
		"  No special section properties.\n"
		"\n"
		".. data:: ASCIIStored\n"
		"\n"
		"  This section was stored as pure ASCII. This can be useful since it is possible to generate\n"
		"  an ASCII section in a text editor by hand or with any simple printf style script, and then\n"
		"  concatenate it to a .rdc and have a valid section.\n"
		"\n"
		".. data:: LZ4Compressed\n"
		"\n"
		"  This section is compressed with LZ4 on disk.\n"
		"\n"
		".. data:: ZstdCompressed\n"
		"\n"
		"  This section is compressed with Zstd on disk.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SectionFlags_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SectionFlags_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SectionFlags_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_SectionFlags,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SectionFlags_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SectionFlags_type};

static SwigPyGetSet BufferCategory___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__BufferCategory_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"BufferCategory.__dict__", (void *) &BufferCategory___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__BufferCategory_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__BufferCategory_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__BufferCategory_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "BufferCategory",                         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_BufferCategory_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__BufferCategory_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__BufferCategory_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__BufferCategory_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__BufferCategory_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A set of flags describing how this buffer may be used\n"
		"\n"
		".. data:: NoFlags\n"
		"\n"
		"  The buffer will not be used for any of the uses below.\n"
		"\n"
		".. data:: Vertex\n"
		"\n"
		"  The buffer will be used for sourcing vertex input data.\n"
		"\n"
		".. data:: Index\n"
		"\n"
		"  The buffer will be used for sourcing primitive index data.\n"
		"\n"
		".. data:: Constants\n"
		"\n"
		"  The buffer will be used for sourcing shader constant data.\n"
		"\n"
		".. data:: ReadWrite\n"
		"\n"
		"  The buffer will be used for read and write access from shaders.\n"
		"\n"
		".. data:: Indirect\n"
		"\n"
		"  The buffer will be used to provide indirect parameters for launching GPU-based actions.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__BufferCategory_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__BufferCategory_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__BufferCategory_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_BufferCategory,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__BufferCategory_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__BufferCategory_type};

static SwigPyGetSet DescriptorFlags___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DescriptorFlags_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DescriptorFlags.__dict__", (void *) &DescriptorFlags___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DescriptorFlags_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DescriptorFlags_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DescriptorFlags_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "DescriptorFlags",                        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DescriptorFlags_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DescriptorFlags_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__DescriptorFlags_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__DescriptorFlags_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DescriptorFlags_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A set of flags for descriptor properties.\n"
		"\n"
		".. data:: NoFlags\n"
		"\n"
		"  The buffer will not be used for any of the uses below.\n"
		"\n"
		".. data:: RawBuffer\n"
		"\n"
		"  On D3D, a buffer is used as a raw (byte-addressed) buffer.\n"
		"\n"
		".. data:: AppendBuffer\n"
		"\n"
		"  On D3D, a buffer is used as a append/consume view.\n"
		"\n"
		".. data:: CounterBuffer\n"
		"\n"
		"  On D3D, a buffer is used with a structured buffer with associated hidden counter.\n"
		"\n"
		".. data:: ReadOnlyAccess\n"
		"\n"
		"  On GL, a storage image or buffer is bound with read-only access.\n"
		"\n"
		".. data:: WriteOnlyAccess\n"
		"\n"
		"  On GL, a storage image or buffer is bound with write-only access.\n"
		"\n"
		".. data:: InlineData\n"
		"\n"
		"  This descriptor isn't backed by an explicit buffer in the API (though a resource may be provided\n"
		"  for data query purposes during replay), but instead by some virtual or in-line data. For example\n"
		"  in-line constants set directly, or compile/creation time constants.\n"
		"\n"
		"  The exact nature can be determined by the shader reflection data.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DescriptorFlags_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DescriptorFlags_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DescriptorFlags_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DescriptorFlags,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DescriptorFlags_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DescriptorFlags_type};

static SwigPyGetSet TextureCategory___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__TextureCategory_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"TextureCategory.__dict__", (void *) &TextureCategory___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__TextureCategory_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__TextureCategory_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__TextureCategory_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "TextureCategory",                        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_TextureCategory_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__TextureCategory_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__TextureCategory_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__TextureCategory_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__TextureCategory_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A set of flags describing how this texture may be used\n"
		"\n"
		".. data:: NoFlags\n"
		"\n"
		"  The texture will not be used for any of the uses below.\n"
		"\n"
		".. data:: ShaderRead\n"
		"\n"
		"  The texture will be read by a shader.\n"
		"\n"
		".. data:: ColorTarget\n"
		"\n"
		"  The texture will be written to as a color target.\n"
		"\n"
		".. data:: DepthTarget\n"
		"\n"
		"  The texture will be written to and tested against as a depth target.\n"
		"\n"
		".. data:: ShaderReadWrite\n"
		"\n"
		"  The texture will be read and written to by a shader.\n"
		"\n"
		".. data:: SwapBuffer\n"
		"\n"
		"  The texture is part of a window swapchain.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__TextureCategory_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__TextureCategory_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__TextureCategory_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_TextureCategory,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__TextureCategory_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__TextureCategory_type};

static SwigPyGetSet ShaderStageMask___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderStageMask_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderStageMask.__dict__", (void *) &ShaderStageMask___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderStageMask_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderStageMask_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderStageMask_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ShaderStageMask",                        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderStageMask_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderStageMask_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__ShaderStageMask_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__ShaderStageMask_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderStageMask_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A set of flags for ``ShaderStage`` stages\n"
		"\n"
		".. data:: Unknown\n"
		"\n"
		"  No flags set for any shader stages.\n"
		"\n"
		".. data:: Vertex\n"
		"\n"
		"  The flag for :data:`ShaderStage.Vertex`.\n"
		"\n"
		".. data:: Hull\n"
		"\n"
		"  The flag for :data:`ShaderStage.Hull`.\n"
		"\n"
		".. data:: Tess_Control\n"
		"\n"
		"  The flag for :data:`ShaderStage.Tess_Control`.\n"
		"\n"
		".. data:: Domain\n"
		"\n"
		"  The flag for :data:`ShaderStage.Domain`.\n"
		"\n"
		".. data:: Tess_Eval\n"
		"\n"
		"  The flag for :data:`ShaderStage.Tess_Eval`.\n"
		"\n"
		".. data:: Geometry\n"
		"\n"
		"  The flag for :data:`ShaderStage.Geometry`.\n"
		"\n"
		".. data:: Pixel\n"
		"\n"
		"  The flag for :data:`ShaderStage.Pixel`.\n"
		"\n"
		".. data:: Fragment\n"
		"\n"
		"  The flag for :data:`ShaderStage.Fragment`.\n"
		"\n"
		".. data:: Compute\n"
		"\n"
		"  The flag for :data:`ShaderStage.Compute`.\n"
		"\n"
		".. data:: Task\n"
		"\n"
		"  The flag for :data:`ShaderStage.Task`.\n"
		"\n"
		".. data:: Amplification\n"
		"\n"
		"  The flag for :data:`ShaderStage.Amplification`.\n"
		"\n"
		".. data:: Mesh\n"
		"\n"
		"  The flag for :data:`ShaderStage.Mesh`.\n"
		"\n"
		".. data:: RayGen\n"
		"\n"
		"  The flag for :data:`ShaderStage.RayGen`.\n"
		"\n"
		".. data:: Intersection\n"
		"\n"
		"  The flag for :data:`ShaderStage.Intersection`.\n"
		"\n"
		".. data:: AnyHit\n"
		"\n"
		"  The flag for :data:`ShaderStage.AnyHit`.\n"
		"\n"
		".. data:: ClosestHit\n"
		"\n"
		"  The flag for :data:`ShaderStage.ClosestHit`.\n"
		"\n"
		".. data:: Miss\n"
		"\n"
		"  The flag for :data:`ShaderStage.Miss`.\n"
		"\n"
		".. data:: Callable\n"
		"\n"
		"  The flag for :data:`ShaderStage.Callable`.\n"
		"\n"
		".. data:: All\n"
		"\n"
		"  A shorthand version with flags set for all stages together.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderStageMask_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderStageMask_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderStageMask_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderStageMask,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderStageMask_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderStageMask_type};

static SwigPyGetSet ShaderEvents___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderEvents_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderEvents.__dict__", (void *) &ShaderEvents___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderEvents_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderEvents_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderEvents_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ShaderEvents",                           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderEvents_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderEvents_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__ShaderEvents_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__ShaderEvents_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderEvents_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A set of flags for events that may occur while debugging a shader\n"
		"\n"
		".. data:: NoEvent\n"
		"\n"
		"  No event has occurred.\n"
		"\n"
		".. data:: SampleLoadGather\n"
		"\n"
		"  A texture was sampled, loaded or gathered.\n"
		"\n"
		".. data:: GeneratedNanOrInf\n"
		"\n"
		"  A floating point operation generated a ``NaN`` or ``infinity`` result.\n"
		"\n"
		".. data:: DebugBreak\n"
		"\n"
		"  A debugbreak event was emitted.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderEvents_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderEvents_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderEvents_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderEvents,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderEvents_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderEvents_type};

static SwigPyGetSet ShaderVariableFlags___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderVariableFlags_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderVariableFlags.__dict__", (void *) &ShaderVariableFlags___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderVariableFlags_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderVariableFlags_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderVariableFlags_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ShaderVariableFlags",                    /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderVariableFlags_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderVariableFlags_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__ShaderVariableFlags_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__ShaderVariableFlags_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderVariableFlags_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A set of flags for events that control how a shader/buffer value is interpreted and\n"
		"displayed\n"
		"\n"
		".. data:: NoFlags\n"
		"\n"
		"  No flags are specified.\n"
		"\n"
		".. data:: RowMajorMatrix\n"
		"\n"
		"  This matrix is stored in row-major order in memory, instead of column-major. In RenderDoc values\n"
		"  are always provided row-major regardless, for consistency of access, but if this flag is not\n"
		"  present then the original values were in column order in memory, so the data has been transposed.\n"
		"\n"
		".. data:: HexDisplay\n"
		"\n"
		"  This value should be displayed using hexadecimal where possible.\n"
		"\n"
		".. data:: BinaryDisplay\n"
		"\n"
		"  This value should be displayed using binary where possible.\n"
		"\n"
		".. data:: RGBDisplay\n"
		"\n"
		"  This value should be interpreted as an RGB colour for display where possible.\n"
		"\n"
		".. data:: R11G11B10\n"
		"\n"
		"  This value should be decoded from a 32-bit integer in R11G11B10 packing format.\n"
		"\n"
		".. data:: R10G10B10A2\n"
		"\n"
		"  This value should be decoded from a 32-bit integer in R10G10B10A2 packing format.\n"
		"\n"
		".. data:: UNorm\n"
		"\n"
		"  This value should be treated as unsigned normalised floating point values when interpreting.\n"
		"\n"
		".. data:: SNorm\n"
		"\n"
		"  This value should be treated as signed normalised floating point values when interpreting.\n"
		"\n"
		".. data:: Truncated\n"
		"\n"
		"  This value was truncated when reading - the available range was exhausted.\n"
		"\n"
		".. data:: SignedEnum\n"
		"\n"
		"  For enums, the base type is a signed integer allowing signed values.\n"
		"\n"
		".. data:: SingleElementArray\n"
		"\n"
		"  In some cases it can be possible to represent and need to distinguish a variable declared as\n"
		"  an array of size 1 from a scalar object. This flag indicates that even though elements == 1\n"
		"  normally means 'not an array', in this case it means an array of size 1.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderVariableFlags_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderVariableFlags_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderVariableFlags_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderVariableFlags, /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderVariableFlags_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderVariableFlags_type};

static SwigPyGetSet ActionFlags___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ActionFlags_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ActionFlags.__dict__", (void *) &ActionFlags___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ActionFlags_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ActionFlags_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ActionFlags_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "ActionFlags",                            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ActionFlags_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ActionFlags_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__ActionFlags_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__ActionFlags_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ActionFlags_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"A set of flags describing the properties of a particular action. An action is a call\n"
		"such as a draw, a compute dispatch, clears, copies, resolves, etc. Any GPU event which may have\n"
		"deliberate visible side-effects to application-visible memory, typically resources such as textures\n"
		"and buffers. It also includes markers, which provide a user-generated annotation of events and\n"
		"actions.\n"
		"\n"
		".. data:: NoFlags\n"
		"\n"
		"  The action has no special properties.\n"
		"\n"
		".. data:: Clear\n"
		"\n"
		"  The action is a clear call. See :data:`ClearColor` and :data:`ClearDepthStencil`.\n"
		"\n"
		".. data:: Drawcall\n"
		"\n"
		"  The action renders primitives using the graphics pipeline.\n"
		"\n"
		".. data:: Dispatch\n"
		"\n"
		"  The action issues a number of compute workgroups.\n"
		"\n"
		".. data:: MeshDispatch\n"
		"\n"
		"  The action issues a number of mesh groups for a draw.\n"
		"\n"
		".. data:: CmdList\n"
		"\n"
		"  The action calls into a previously recorded child command list.\n"
		"\n"
		".. data:: SetMarker\n"
		"\n"
		"  The action inserts a single debugging marker.\n"
		"\n"
		".. data:: PushMarker\n"
		"\n"
		"  The action begins a debugging marker region that has children.\n"
		"\n"
		".. data:: PopMarker\n"
		"\n"
		"  The action ends a debugging marker region.\n"
		"\n"
		".. data:: Present\n"
		"\n"
		"  The action is a presentation call that hands a swapchain image to the presentation engine.\n"
		"\n"
		".. data:: MultiAction\n"
		"\n"
		"  The action is a multi-action that contains several specified child actions. Typically a MultiDraw\n"
		"  or ExecuteIndirect on D3D12.\n"
		"\n"
		".. data:: Copy\n"
		"\n"
		"  The action performs a resource copy operation.\n"
		"\n"
		".. data:: Resolve\n"
		"\n"
		"  The action performs a resource resolve or blit operation.\n"
		"\n"
		".. data:: GenMips\n"
		"\n"
		"  The action performs a resource mip-generation operation.\n"
		"\n"
		".. data:: PassBoundary\n"
		"\n"
		"  The action marks the beginning or end of a render pass. See :data:`BeginPass` and\n"
		"  :data:`EndPass`.\n"
		"\n"
		".. data:: DispatchRay\n"
		"\n"
		"  This action issues a number of rays.\n"
		"\n"
		".. data:: BuildAccStruct\n"
		"\n"
		"  This action builds or copies to and implicitly fills an acceleration structure.\n"
		"\n"
		".. data:: Indexed\n"
		"\n"
		"  The action uses an index buffer.\n"
		"\n"
		".. data:: Instanced\n"
		"\n"
		"  The action uses instancing. This does not mean it renders more than one instanced, simply that\n"
		"  it uses the instancing feature.\n"
		"\n"
		".. data:: Auto\n"
		"\n"
		"  The action interacts with stream-out to render all vertices previously written. This is a\n"
		"  Direct3D 11 specific feature.\n"
		"\n"
		".. data:: Indirect\n"
		"\n"
		"  The action uses a buffer on the GPU to source some or all of its parameters in an indirect way.\n"
		"\n"
		".. data:: ClearColor\n"
		"\n"
		"  The action clears a color target.\n"
		"\n"
		".. data:: ClearDepthStencil\n"
		"\n"
		"  The action clears a depth-stencil target.\n"
		"\n"
		".. data:: BeginPass\n"
		"\n"
		"  The action marks the beginning of a render pass.\n"
		"\n"
		".. data:: EndPass\n"
		"\n"
		"  The action marks the end of a render pass.\n"
		"\n"
		".. data:: CommandBufferBoundary\n"
		"\n"
		"  The action is a virtual marker added to show command buffer boundaries.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ActionFlags_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ActionFlags_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ActionFlags_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ActionFlags,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ActionFlags_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ActionFlags_type};

static SwigPyGetSet VulkanLayerFlags___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VulkanLayerFlags_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VulkanLayerFlags.__dict__", (void *) &VulkanLayerFlags___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VulkanLayerFlags_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VulkanLayerFlags_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VulkanLayerFlags_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "VulkanLayerFlags",                       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VulkanLayerFlags_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VulkanLayerFlags_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__VulkanLayerFlags_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__VulkanLayerFlags_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VulkanLayerFlags_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"INTERNAL: A set of flags giving details of the current status of vulkan layer\n"
		"registration.\n"
		"\n"
		".. data:: NoFlags\n"
		"\n"
		"  There are no problems with the vulkan layer registration.\n"
		"\n"
		".. data:: OtherInstallsRegistered\n"
		"\n"
		"  Other conflicting installs of the same layer in other locations are registered.\n"
		"\n"
		".. data:: ThisInstallRegistered\n"
		"\n"
		"  This current install of the layer is registered.\n"
		"\n"
		".. data:: NeedElevation\n"
		"\n"
		"  Fixing any issues will require elevation to system administrator privileges.\n"
		"\n"
		".. data:: UserRegisterable\n"
		"\n"
		"  This layer can be registered as user-local, as well as system-wide. If :data:`NeedElevation` isn't\n"
		"  also set then the entire process can be done un-elevated if user-local is desired.\n"
		"\n"
		"  .. note::\n"
		"\n"
		"    If the :data:`NeedElevation` flag is set then elevation is required to fix the layer\n"
		"    registration, even if a user-local registration is desired.\n"
		"\n"
		"    Most commonly this situation arises if there is no other registration, or the existing one is\n"
		"    already user-local.\n"
		"\n"
		".. data:: RegisterAll\n"
		"\n"
		"  All listed locations for the current layer must be registered for correct functioning.\n"
		"\n"
		"  If this flag is not set, then the listed locations are an 'or' list of alternatives.\n"
		"\n"
		".. data:: UpdateAllowed\n"
		"\n"
		"  If the current registrations can be updated or re-pointed to fix the issues.\n"
		"\n"
		".. data:: Unfixable\n"
		"\n"
		"  The current situation is not fixable automatically and requires user intervention/disambiguation.\n"
		"\n"
		".. data:: Unsupported\n"
		"\n"
		"  Vulkan is not supported by this build of RenderDoc and the layer cannot be registered.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VulkanLayerFlags_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VulkanLayerFlags_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VulkanLayerFlags_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VulkanLayerFlags,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VulkanLayerFlags_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VulkanLayerFlags_type};

static SwigPyGetSet AndroidFlags___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__AndroidFlags_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"AndroidFlags.__dict__", (void *) &AndroidFlags___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__AndroidFlags_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__AndroidFlags_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__AndroidFlags_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "AndroidFlags",                           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_AndroidFlags_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__AndroidFlags_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__AndroidFlags_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__AndroidFlags_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__AndroidFlags_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"INTERNAL: A set of flags giving details of the current status of Android tracability.\n"
		"\n"
		".. data:: NoFlags\n"
		"\n"
		"  There are no problems with the Android application setup.\n"
		"\n"
		".. data:: Debuggable\n"
		"\n"
		"  The application is debuggable.\n"
		"\n"
		".. data:: RootAccess\n"
		"\n"
		"   The device being targeted has root access.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__AndroidFlags_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__AndroidFlags_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__AndroidFlags_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_AndroidFlags,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__AndroidFlags_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__AndroidFlags_type};

static SwigPyGetSet PointerVal___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet PointerVal_shader_getset = { _wrap_PointerVal_shader_get, _wrap_PointerVal_shader_set };
static SwigPyGetSet PointerVal_pointer_getset = { _wrap_PointerVal_pointer_get, _wrap_PointerVal_pointer_set };
static SwigPyGetSet PointerVal_pointerTypeID_getset = { _wrap_PointerVal_pointerTypeID_get, _wrap_PointerVal_pointerTypeID_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__PointerVal_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"PointerVal.__dict__", (void *) &PointerVal___dict___getset }
,
    { (char *) "shader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An optional :class:`ResourceId` identifying the shader containing the type info.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &PointerVal_shader_getset }
,
    { (char *) "pointer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The actual pointer value itself.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &PointerVal_pointer_getset }
,
    { (char *) "pointerTypeID", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index into :data:`ShaderReflection.pointerTypes` of the pointed type.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &PointerVal_pointerTypeID_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__PointerVal_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__PointerVal_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__PointerVal_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.PointerVal",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_PointerVal_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__PointerVal_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__PointerVal_type.as_sequence,                  /* tp_as_sequence */
    &SwigPyBuiltin__PointerVal_type.as_mapping,                   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__PointerVal_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A 64-bit pointer value with optional type information.",     /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__PointerVal_richcompare,          /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__PointerVal_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__PointerVal_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_PointerVal,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__PointerVal_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__PointerVal_type};

static SwigPyGetSet ShaderBindIndex___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderBindIndex_category_getset = { _wrap_ShaderBindIndex_category_get, _wrap_ShaderBindIndex_category_set };
static SwigPyGetSet ShaderBindIndex_index_getset = { _wrap_ShaderBindIndex_index_get, _wrap_ShaderBindIndex_index_set };
static SwigPyGetSet ShaderBindIndex_arrayElement_getset = { _wrap_ShaderBindIndex_arrayElement_get, _wrap_ShaderBindIndex_arrayElement_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderBindIndex_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderBindIndex.__dict__", (void *) &ShaderBindIndex___dict___getset }
,
    { (char *) "category", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The type of binding this refers to, with each category referring to a different\n"
		"shader interface in the :data:`ShaderReflection`.\n"
		"\n"
		":type: DescriptorCategory\n"
		"\n"
		"", (void *) &ShaderBindIndex_category_getset }
,
    { (char *) "index", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index within the given :data:`category` for the binding.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderBindIndex_index_getset }
,
    { (char *) "arrayElement", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If the binding identified by :data:`category` and :data:`index` is arrayed, this\n"
		"identifies the particular array index being referred to.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderBindIndex_arrayElement_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderBindIndex_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderBindIndex___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderBindIndex___lt__(self, other); break;
    case Py_GT : result = _wrap_ShaderBindIndex___gt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderBindIndex_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ShaderBindIndex___lt__, METH_O, (char *) "__lt__(o)" },
  { "__gt__", (PyCFunction) _wrap_ShaderBindIndex___gt__, METH_O, (char *) "__gt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ShaderBindIndex___eq__, METH_O, (char *) "__eq__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderBindIndex_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderBindIndex",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderBindIndex_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderBindIndex_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__ShaderBindIndex_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__ShaderBindIndex_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderBindIndex_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"References a particular individual binding element in a shader interface.\n"
		"\n"
		"This is the shader interface side of a :class:`DescriptorAccess` and so can be compared to one to\n"
		"check if an access refers to a given index or not.\n"
		"\n"
		"The context of which shader reflection this index refers to must be provided to properly interpret\n"
		"this information, as it is relative to a particular :class:`ShaderReflection`.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderBindIndex_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderBindIndex_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderBindIndex_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderBindIndex,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderBindIndex_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderBindIndex_type};

static SwigPyGetSet ShaderDirectAccess_descriptorStore_getset = { _wrap_ShaderDirectAccess_descriptorStore_get, _wrap_ShaderDirectAccess_descriptorStore_set };
static SwigPyGetSet ShaderDirectAccess___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderDirectAccess_byteOffset_getset = { _wrap_ShaderDirectAccess_byteOffset_get, _wrap_ShaderDirectAccess_byteOffset_set };
static SwigPyGetSet ShaderDirectAccess_type_getset = { _wrap_ShaderDirectAccess_type_get, _wrap_ShaderDirectAccess_type_set };
static SwigPyGetSet ShaderDirectAccess_byteSize_getset = { _wrap_ShaderDirectAccess_byteSize_get, _wrap_ShaderDirectAccess_byteSize_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderDirectAccess_getset[] = {
    { (char *) "descriptorStore", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The backing storage of the descriptor.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &ShaderDirectAccess_descriptorStore_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderDirectAccess.__dict__", (void *) &ShaderDirectAccess___dict___getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in bytes to the descriptor in the descriptor store.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderDirectAccess_byteOffset_getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The type of the resource being accessed.\n"
		"\n"
		":type: DescriptorType\n"
		"\n"
		"", (void *) &ShaderDirectAccess_type_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size in bytes of the descriptor.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderDirectAccess_byteSize_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderDirectAccess_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderDirectAccess___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderDirectAccess___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderDirectAccess_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ShaderDirectAccess___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ShaderDirectAccess___eq__, METH_O, (char *) "__eq__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderDirectAccess_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderDirectAccess",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderDirectAccess_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderDirectAccess_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__ShaderDirectAccess_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__ShaderDirectAccess_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderDirectAccess_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"References a particular resource accessed via the shader using direct heap access (as opposed to a direct binding).\n"
		"\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderDirectAccess_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderDirectAccess_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderDirectAccess_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderDirectAccess,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderDirectAccess_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderDirectAccess_type};

static SwigPyGetSet ShaderValue_u32v_getset = { _wrap_ShaderValue_u32v_get, _wrap_ShaderValue_u32v_set };
static SwigPyGetSet ShaderValue_s16v_getset = { _wrap_ShaderValue_s16v_get, _wrap_ShaderValue_s16v_set };
static SwigPyGetSet ShaderValue_f32v_getset = { _wrap_ShaderValue_f32v_get, _wrap_ShaderValue_f32v_set };
static SwigPyGetSet ShaderValue_u16v_getset = { _wrap_ShaderValue_u16v_get, _wrap_ShaderValue_u16v_set };
static SwigPyGetSet ShaderValue_f16v_getset = { _wrap_ShaderValue_f16v_get, _wrap_ShaderValue_f16v_set };
static SwigPyGetSet ShaderValue___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderValue_s64v_getset = { _wrap_ShaderValue_s64v_get, _wrap_ShaderValue_s64v_set };
static SwigPyGetSet ShaderValue_s8v_getset = { _wrap_ShaderValue_s8v_get, _wrap_ShaderValue_s8v_set };
static SwigPyGetSet ShaderValue_u64v_getset = { _wrap_ShaderValue_u64v_get, _wrap_ShaderValue_u64v_set };
static SwigPyGetSet ShaderValue_f64v_getset = { _wrap_ShaderValue_f64v_get, _wrap_ShaderValue_f64v_set };
static SwigPyGetSet ShaderValue_u8v_getset = { _wrap_ShaderValue_u8v_get, _wrap_ShaderValue_u8v_set };
static SwigPyGetSet ShaderValue_s32v_getset = { _wrap_ShaderValue_s32v_get, _wrap_ShaderValue_s32v_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderValue_getset[] = {
    { (char *) "u32v", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"16-tuple of 32-bit unsigned integer values.\n"
		"\n"
		":type: Tuple[int,...]\n"
		"\n"
		"", (void *) &ShaderValue_u32v_getset }
,
    { (char *) "s16v", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"16-tuple of 16-bit signed integer values.\n"
		"\n"
		":type: Tuple[int,...]\n"
		"\n"
		"", (void *) &ShaderValue_s16v_getset }
,
    { (char *) "f32v", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"16-tuple of ``float`` values.\n"
		"\n"
		":type: Tuple[float,...]\n"
		"\n"
		"", (void *) &ShaderValue_f32v_getset }
,
    { (char *) "u16v", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"16-tuple of 16-bit unsigned integer values.\n"
		"\n"
		":type: Tuple[int,...]\n"
		"\n"
		"", (void *) &ShaderValue_u16v_getset }
,
    { (char *) "f16v", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"16-tuple of 16-bit half-precision float values.\n"
		"\n"
		":type: Tuple[int,...]\n"
		"\n"
		"", (void *) &ShaderValue_f16v_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderValue.__dict__", (void *) &ShaderValue___dict___getset }
,
    { (char *) "s64v", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"16-tuple of 64-bit signed integer values.\n"
		"\n"
		":type: Tuple[int,...]\n"
		"\n"
		"", (void *) &ShaderValue_s64v_getset }
,
    { (char *) "s8v", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"16-tuple of 8-bit signed integer values.\n"
		"\n"
		":type: Tuple[int,...]\n"
		"\n"
		"", (void *) &ShaderValue_s8v_getset }
,
    { (char *) "u64v", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"16-tuple of 64-bit unsigned integer values.\n"
		"\n"
		":type: Tuple[int,...]\n"
		"\n"
		"", (void *) &ShaderValue_u64v_getset }
,
    { (char *) "f64v", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"16-tuple of ``double`` values.\n"
		"\n"
		":type: Tuple[float,...]\n"
		"\n"
		"", (void *) &ShaderValue_f64v_getset }
,
    { (char *) "u8v", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"16-tuple of 8-bit unsigned integer values.\n"
		"\n"
		":type: Tuple[int,...]\n"
		"\n"
		"", (void *) &ShaderValue_u8v_getset }
,
    { (char *) "s32v", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"16-tuple of 32-bit signed integer values.\n"
		"\n"
		":type: Tuple[int,...]\n"
		"\n"
		"", (void *) &ShaderValue_s32v_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderValue_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderValue_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderValue_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderValue",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderValue_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderValue_type.as_number,                   /* tp_as_number */
    &SwigPyBuiltin__ShaderValue_type.as_sequence,                 /* tp_as_sequence */
    &SwigPyBuiltin__ShaderValue_type.as_mapping,                  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderValue_type.as_buffer,                   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A C union that holds 16 values, with each different basic variable type.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderValue_richcompare,         /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderValue_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderValue_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderValue,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderValue_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderValue_type};

static SwigPyGetSet ShaderVariable_value_getset = { _wrap_ShaderVariable_value_get, _wrap_ShaderVariable_value_set };
static SwigPyGetSet ShaderVariable_name_getset = { _wrap_ShaderVariable_name_get, _wrap_ShaderVariable_name_set };
static SwigPyGetSet ShaderVariable_members_getset = { _wrap_ShaderVariable_members_get, _wrap_ShaderVariable_members_set };
static SwigPyGetSet ShaderVariable_rows_getset = { _wrap_ShaderVariable_rows_get, _wrap_ShaderVariable_rows_set };
static SwigPyGetSet ShaderVariable___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderVariable_type_getset = { _wrap_ShaderVariable_type_get, _wrap_ShaderVariable_type_set };
static SwigPyGetSet ShaderVariable_flags_getset = { _wrap_ShaderVariable_flags_get, _wrap_ShaderVariable_flags_set };
static SwigPyGetSet ShaderVariable_columns_getset = { _wrap_ShaderVariable_columns_get, _wrap_ShaderVariable_columns_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderVariable_getset[] = {
    { (char *) "value", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The contents of this variable if it has no members.\n"
		"\n"
		":type: ShaderValue\n"
		"\n"
		"", (void *) &ShaderVariable_value_getset }
,
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of this variable.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderVariable_name_getset }
,
    { (char *) "members", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The members of this variable.\n"
		"\n"
		":type: List[ShaderVariable]\n"
		"\n"
		"", (void *) &ShaderVariable_members_getset }
,
    { (char *) "rows", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of rows in this matrix.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderVariable_rows_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderVariable.__dict__", (void *) &ShaderVariable___dict___getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`basic type <VarType>` of this variable.\n"
		"\n"
		":type: VarType\n"
		"\n"
		"", (void *) &ShaderVariable_type_getset }
,
    { (char *) "flags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The flags controlling how this constant is interpreted and displayed.\n"
		"\n"
		":type: ShaderVariableFlags\n"
		"\n"
		"", (void *) &ShaderVariable_flags_getset }
,
    { (char *) "columns", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of columns in this matrix.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderVariable_columns_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderVariable_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderVariable___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderVariable___lt__(self, other); break;
    case Py_NE : result = _wrap_ShaderVariable___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderVariable_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ShaderVariable___lt__, METH_O, (char *) "__lt__(o)" },
  { "RowMajor", (PyCFunction) _wrap_ShaderVariable_RowMajor, METH_NOARGS, (char *) "\n"
		"RowMajor()\n"
		"\n"
		"Helper function for checking if :data:`flags` has\n"
		":data:`ShaderVariableFlags.RowMajorMatrix` set. This is entirely equivalent to checking that flag\n"
		"manually, but since it is common this helper is provided.\n"
		"\n"
		".. note::\n"
		"  Vectors and scalars will be marked as row-major by convention for convenience.\n"
		"\n"
		":return: If the storage is row-major order in memory\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "ColMajor", (PyCFunction) _wrap_ShaderVariable_ColMajor, METH_NOARGS, (char *) "\n"
		"ColMajor()\n"
		"\n"
		"Helper function for checking if :data:`flags` *does not* have\n"
		":data:`ShaderVariableFlags.RowMajorMatrix` set. This is entirely equivalent to checking that flag\n"
		"manually, but since it is common this helper is provided.\n"
		"\n"
		".. note::\n"
		"  Vectors and scalars will be marked as row-major by convention for convenience.\n"
		"\n"
		":return: If the storage is column-major order in memory\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "SetTypelessPointer", (PyCFunction) _wrap_ShaderVariable_SetTypelessPointer, METH_O, (char *) "\n"
		"SetTypelessPointer(pointer)\n"
		"\n"
		"Utility function for setting a pointer value with no type information.\n"
		"\n"
		":param int pointer: The actual pointer value.\n"
		"\n"
		"" },
  { "SetTypedPointer", (PyCFunction) _wrap_ShaderVariable_SetTypedPointer, METH_VARARGS, (char *) "\n"
		"SetTypedPointer(pointer, shader, pointerTypeID)\n"
		"\n"
		"Utility function for setting a pointer value with type information.\n"
		"\n"
		":param int pointer: The actual pointer value.\n"
		":param ResourceId shader: The shader containing the type information.\n"
		":param int pointerTypeID: The type's index in the shader's :data:`ShaderReflection.pointerTypes`\n"
		"  list.\n"
		"\n"
		"" },
  { "GetPointer", (PyCFunction) _wrap_ShaderVariable_GetPointer, METH_NOARGS, (char *) "\n"
		"GetPointer()\n"
		"\n"
		"Utility function for getting a pointer value, with optional type information.\n"
		"\n"
		".. note::\n"
		"\n"
		"  The return value is undefined if this variable is not a pointer.\n"
		"\n"
		":return: A :class:`PointerVal` with the pointer value.\n"
		":rtype: PointerVal\n"
		"\n"
		"" },
  { "SetBindIndex", (PyCFunction) _wrap_ShaderVariable_SetBindIndex, METH_O, (char *) "\n"
		"SetBindIndex(idx)\n"
		"\n"
		"Utility function for setting a reference to a shader binding.\n"
		"\n"
		"The :class:`ShaderBindIndex` uniquely refers to a given shader binding in one of the shader interfaces\n"
		"(constant blocks, samplers, read-only and read-write resources) and if necessary the element within\n"
		"an arrayed binding.\n"
		"\n"
		":param ShaderBindIndex idx: The index of the bind being referred to.\n"
		"\n"
		"" },
  { "GetBindIndex", (PyCFunction) _wrap_ShaderVariable_GetBindIndex, METH_NOARGS, (char *) "\n"
		"GetBindIndex()\n"
		"\n"
		"Utility function for getting a shader binding referenced by this variable.\n"
		"\n"
		".. note::\n"
		"\n"
		"  The return value is undefined if this variable is not a binding reference.\n"
		"\n"
		":return: A :class:`ShaderBindIndex` with the binding referenced.\n"
		":rtype: ShaderBindIndex\n"
		"\n"
		"" },
  { "SetDirectAccess", (PyCFunction) _wrap_ShaderVariable_SetDirectAccess, METH_O, (char *) "\n"
		"SetDirectAccess(access)\n"
		"\n"
		"Utility function for setting a resource which is accessed directly from a shader without using bindings.\n"
		"\n"
		"The :class:`ShaderDirectAccess` uniquely refers to a resource descriptor.\n"
		"\n"
		":param ShaderDirectAccess access: The resource descriptor being referenced.\n"
		"\n"
		"" },
  { "GetDirectAccess", (PyCFunction) _wrap_ShaderVariable_GetDirectAccess, METH_NOARGS, (char *) "\n"
		"GetDirectAccess()\n"
		"\n"
		"Utility function for getting the resource which is accessed directly from a shader without using bindings.\n"
		"\n"
		".. note::\n"
		"\n"
		"  The return value is undefined if this variable is not a resource referenced directly by a shader.\n"
		"\n"
		":return: A :class:`ShaderDirectAccess` containing the resource reference.\n"
		":rtype: ShaderDirectAccess\n"
		"\n"
		"" },
  { "IsDirectAccess", (PyCFunction) _wrap_ShaderVariable_IsDirectAccess, METH_NOARGS, (char *) "\n"
		"IsDirectAccess()\n"
		"\n"
		"Utility function to check if this variable stores a resource reference directly accessed by a shader.\n"
		"\n"
		":return: If the variable represents a :class:`ShaderDirectAccess`.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "__eq__", (PyCFunction) _wrap_ShaderVariable___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_ShaderVariable___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderVariable_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderVariable",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderVariable_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderVariable_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__ShaderVariable_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__ShaderVariable_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderVariable_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Holds a single named shader variable. It contains either a primitive type (up to a 4x4\n"
		"matrix of a :class:`basic type <VarType>`) or a list of members, which can either be struct or array\n"
		"members of this parent variable.\n"
		"\n"
		"Matrices are always stored row-major. If necessary they are transposed when retrieving from the raw\n"
		"data bytes when they are specified to be column-major in the API/shader metadata.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderVariable_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderVariable_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderVariable_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderVariable,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderVariable_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderVariable_type};

static SwigPyGetSet DebugVariableReference_name_getset = { _wrap_DebugVariableReference_name_get, _wrap_DebugVariableReference_name_set };
static SwigPyGetSet DebugVariableReference_component_getset = { _wrap_DebugVariableReference_component_get, _wrap_DebugVariableReference_component_set };
static SwigPyGetSet DebugVariableReference___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet DebugVariableReference_type_getset = { _wrap_DebugVariableReference_type_get, _wrap_DebugVariableReference_type_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__DebugVariableReference_getset[] = {
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of the base debug variable.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &DebugVariableReference_name_getset }
,
    { (char *) "component", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The component within the variable.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &DebugVariableReference_component_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"DebugVariableReference.__dict__", (void *) &DebugVariableReference___dict___getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The type of variable this is referring to.\n"
		"\n"
		":type: DebugVariableType\n"
		"\n"
		"", (void *) &DebugVariableReference_type_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__DebugVariableReference_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_DebugVariableReference___eq__(self, other); break;
    case Py_LT : result = _wrap_DebugVariableReference___lt__(self, other); break;
    case Py_NE : result = _wrap_DebugVariableReference___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__DebugVariableReference_methods[] = {
  { "__lt__", (PyCFunction) _wrap_DebugVariableReference___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_DebugVariableReference___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_DebugVariableReference___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__DebugVariableReference_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.DebugVariableReference",       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_DebugVariableReference_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__DebugVariableReference_type.as_number,        /* tp_as_number */
    &SwigPyBuiltin__DebugVariableReference_type.as_sequence,      /* tp_as_sequence */
    &SwigPyBuiltin__DebugVariableReference_type.as_mapping,       /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__DebugVariableReference_type.as_buffer,        /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A particular component of a debugging variable that a high-level variable component maps to",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__DebugVariableReference_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__DebugVariableReference_methods,                /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__DebugVariableReference_getset,                 /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_DebugVariableReference,                  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__DebugVariableReference_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__DebugVariableReference_type};

static SwigPyGetSet SourceVariableMapping_signatureIndex_getset = { _wrap_SourceVariableMapping_signatureIndex_get, _wrap_SourceVariableMapping_signatureIndex_set };
static SwigPyGetSet SourceVariableMapping_name_getset = { _wrap_SourceVariableMapping_name_get, _wrap_SourceVariableMapping_name_set };
static SwigPyGetSet SourceVariableMapping_rows_getset = { _wrap_SourceVariableMapping_rows_get, _wrap_SourceVariableMapping_rows_set };
static SwigPyGetSet SourceVariableMapping_variables_getset = { _wrap_SourceVariableMapping_variables_get, _wrap_SourceVariableMapping_variables_set };
static SwigPyGetSet SourceVariableMapping_undefinedValue_getset = { _wrap_SourceVariableMapping_undefinedValue_get, _wrap_SourceVariableMapping_undefinedValue_set };
static SwigPyGetSet SourceVariableMapping___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet SourceVariableMapping_offset_getset = { _wrap_SourceVariableMapping_offset_get, _wrap_SourceVariableMapping_offset_set };
static SwigPyGetSet SourceVariableMapping_type_getset = { _wrap_SourceVariableMapping_type_get, _wrap_SourceVariableMapping_type_set };
static SwigPyGetSet SourceVariableMapping_columns_getset = { _wrap_SourceVariableMapping_columns_get, _wrap_SourceVariableMapping_columns_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SourceVariableMapping_getset[] = {
    { (char *) "signatureIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index in the input or output signature of the shader that this variable represents.\n"
		"\n"
		"The type of signature can be disambiguated by the debug variables referenced - inputs are stored\n"
		"separately.\n"
		"\n"
		"This will be set to -1 if the variable is not part of either signature.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SourceVariableMapping_signatureIndex_getset }
,
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name and member of this source variable that's being mapped from.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &SourceVariableMapping_name_getset }
,
    { (char *) "rows", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of rows in this variable - 1 for vectors, >1 for matrices.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SourceVariableMapping_rows_getset }
,
    { (char *) "variables", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The debug variables that the components of this high level variable map to. Multiple\n"
		"ranges could refer to the same variable if a contiguous range is mapped to - the mapping is\n"
		"component-by-component to greatly simplify algorithms at the expense of a small amount of storage\n"
		"space.\n"
		"\n"
		":type: List[DebugVariableReference]\n"
		"\n"
		"", (void *) &SourceVariableMapping_variables_getset }
,
    { (char *) "undefinedValue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A flag indicating if this mapping indicates an undefined value - the meaning of which\n"
		"is compiler defined but may mean either uninitialised data, unassigned values, or optimised away values.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &SourceVariableMapping_undefinedValue_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SourceVariableMapping.__dict__", (void *) &SourceVariableMapping___dict___getset }
,
    { (char *) "offset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in the parent source variable, for struct members. Useful for sorting.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SourceVariableMapping_offset_getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The variable type of the source being mapped from, if the debug variable is untyped.\n"
		"\n"
		":type: VarType\n"
		"\n"
		"", (void *) &SourceVariableMapping_type_getset }
,
    { (char *) "columns", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of columns in this variable.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SourceVariableMapping_columns_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SourceVariableMapping_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_SourceVariableMapping___eq__(self, other); break;
    case Py_LT : result = _wrap_SourceVariableMapping___lt__(self, other); break;
    case Py_NE : result = _wrap_SourceVariableMapping___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SourceVariableMapping_methods[] = {
  { "__lt__", (PyCFunction) _wrap_SourceVariableMapping___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_SourceVariableMapping___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_SourceVariableMapping___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SourceVariableMapping_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.SourceVariableMapping",        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_SourceVariableMapping_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SourceVariableMapping_type.as_number,         /* tp_as_number */
    &SwigPyBuiltin__SourceVariableMapping_type.as_sequence,       /* tp_as_sequence */
    &SwigPyBuiltin__SourceVariableMapping_type.as_mapping,        /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SourceVariableMapping_type.as_buffer,         /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Maps the contents of a high-level source variable to one or more shader variables in a\n"
		":class:`ShaderDebugState`, with type information.\n"
		"\n"
		"A single high-level variable may be represented by multiple mappings but only along regular\n"
		"boundaries, typically whole vectors. For example an array may have each element in a different\n"
		"mapping, or a matrix may have a mapping per row. The properties such as :data:`rows` and\n"
		":data:`elements` reflect the *parent* object.\n"
		"\n"
		".. note::\n"
		"\n"
		"  There is not necessarily a 1:1 mapping from source variable to debug variable, so this can change\n"
		"  over time.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SourceVariableMapping_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SourceVariableMapping_methods,                 /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SourceVariableMapping_getset,                  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_SourceVariableMapping,                   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SourceVariableMapping_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SourceVariableMapping_type};

static SwigPyGetSet LineColumnInfo_disassemblyLine_getset = { _wrap_LineColumnInfo_disassemblyLine_get, _wrap_LineColumnInfo_disassemblyLine_set };
static SwigPyGetSet LineColumnInfo_fileIndex_getset = { _wrap_LineColumnInfo_fileIndex_get, _wrap_LineColumnInfo_fileIndex_set };
static SwigPyGetSet LineColumnInfo_lineEnd_getset = { _wrap_LineColumnInfo_lineEnd_get, _wrap_LineColumnInfo_lineEnd_set };
static SwigPyGetSet LineColumnInfo_lineStart_getset = { _wrap_LineColumnInfo_lineStart_get, _wrap_LineColumnInfo_lineStart_set };
static SwigPyGetSet LineColumnInfo_colStart_getset = { _wrap_LineColumnInfo_colStart_get, _wrap_LineColumnInfo_colStart_set };
static SwigPyGetSet LineColumnInfo___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet LineColumnInfo_colEnd_getset = { _wrap_LineColumnInfo_colEnd_get, _wrap_LineColumnInfo_colEnd_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__LineColumnInfo_getset[] = {
    { (char *) "disassemblyLine", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The line (starting from 1) in the disassembly where this instruction is located.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &LineColumnInfo_disassemblyLine_getset }
,
    { (char *) "fileIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current file, as an index into the list of files for this shader.\n"
		"\n"
		"If this is negative, no source mapping is available and only :data:`disassemblyLine` is valid.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &LineColumnInfo_fileIndex_getset }
,
    { (char *) "lineEnd", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The ending line-number (starting from 1) of the source code.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &LineColumnInfo_lineEnd_getset }
,
    { (char *) "lineStart", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The starting line-number (starting from 1) of the source code.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &LineColumnInfo_lineStart_getset }
,
    { (char *) "colStart", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The column number (starting from 1) of the start of the code on the line specified by\n"
		":data:`lineStart`. If set to 0, no column information is available and the whole lines should be\n"
		"treated as covering the code.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &LineColumnInfo_colStart_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"LineColumnInfo.__dict__", (void *) &LineColumnInfo___dict___getset }
,
    { (char *) "colEnd", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The column number (starting from 1) of the end of the code on the line specified by\n"
		":data:`lineEnd`. If set to 0, no column information is available and the whole lines should be\n"
		"treated as covering the code.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &LineColumnInfo_colEnd_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__LineColumnInfo_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_LineColumnInfo___eq__(self, other); break;
    case Py_LT : result = _wrap_LineColumnInfo___lt__(self, other); break;
    case Py_NE : result = _wrap_LineColumnInfo___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__LineColumnInfo_methods[] = {
  { "__lt__", (PyCFunction) _wrap_LineColumnInfo___lt__, METH_O, (char *) "__lt__(o)" },
  { "SourceEqual", (PyCFunction) _wrap_LineColumnInfo_SourceEqual, METH_O, (char *) "\n"
		"SourceEqual(o)\n"
		"\n"
		"\n"
		":param LineColumnInfo o: The object to compare against.\n"
		":return: ``True`` if this object is equal to the parameter, disregarding :data:`disassemblyLine`.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "__eq__", (PyCFunction) _wrap_LineColumnInfo___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_LineColumnInfo___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__LineColumnInfo_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.LineColumnInfo",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_LineColumnInfo_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__LineColumnInfo_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__LineColumnInfo_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__LineColumnInfo_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__LineColumnInfo_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Details the current region of code that an instruction maps to",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__LineColumnInfo_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__LineColumnInfo_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__LineColumnInfo_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_LineColumnInfo,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__LineColumnInfo_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__LineColumnInfo_type};

static SwigPyGetSet InstructionSourceInfo___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet InstructionSourceInfo_lineInfo_getset = { _wrap_InstructionSourceInfo_lineInfo_get, _wrap_InstructionSourceInfo_lineInfo_set };
static SwigPyGetSet InstructionSourceInfo_sourceVars_getset = { _wrap_InstructionSourceInfo_sourceVars_get, _wrap_InstructionSourceInfo_sourceVars_set };
static SwigPyGetSet InstructionSourceInfo_instruction_getset = { _wrap_InstructionSourceInfo_instruction_get, _wrap_InstructionSourceInfo_instruction_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__InstructionSourceInfo_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"InstructionSourceInfo.__dict__", (void *) &InstructionSourceInfo___dict___getset }
,
    { (char *) "lineInfo", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The source location that this instruction corresponds to\n"
		"\n"
		":type: LineColumnInfo\n"
		"\n"
		"", (void *) &InstructionSourceInfo_lineInfo_getset }
,
    { (char *) "sourceVars", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An optional mapping of which high-level source variables map to which debug variables\n"
		"and including extra type information.\n"
		"\n"
		"This list contains source variable mapping that is only valid at this instruction, and is fully\n"
		"complete & redundant including all previous source variables that are still valid at this\n"
		"instruction.\n"
		"\n"
		":type: List[SourceVariableMapping]\n"
		"\n"
		"", (void *) &InstructionSourceInfo_sourceVars_getset }
,
    { (char *) "instruction", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The instruction that this information is for.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &InstructionSourceInfo_instruction_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__InstructionSourceInfo_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_InstructionSourceInfo___eq__(self, other); break;
    case Py_LT : result = _wrap_InstructionSourceInfo___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__InstructionSourceInfo_methods[] = {
  { "__eq__", (PyCFunction) _wrap_InstructionSourceInfo___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_InstructionSourceInfo___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__InstructionSourceInfo_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.InstructionSourceInfo",        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_InstructionSourceInfo_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__InstructionSourceInfo_type.as_number,         /* tp_as_number */
    &SwigPyBuiltin__InstructionSourceInfo_type.as_sequence,       /* tp_as_sequence */
    &SwigPyBuiltin__InstructionSourceInfo_type.as_mapping,        /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__InstructionSourceInfo_type.as_buffer,         /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Gives per-instruction source code mapping information, including what line(s) correspond\n"
		"to this instruction and which source variables exist\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__InstructionSourceInfo_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__InstructionSourceInfo_methods,                 /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__InstructionSourceInfo_getset,                  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_InstructionSourceInfo,                   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__InstructionSourceInfo_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__InstructionSourceInfo_type};

static SwigPyGetSet ShaderVariableChange___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderVariableChange_after_getset = { _wrap_ShaderVariableChange_after_get, _wrap_ShaderVariableChange_after_set };
static SwigPyGetSet ShaderVariableChange_before_getset = { _wrap_ShaderVariableChange_before_get, _wrap_ShaderVariableChange_before_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderVariableChange_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderVariableChange.__dict__", (void *) &ShaderVariableChange___dict___getset }
,
    { (char *) "after", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value of the variable after the change. If this variable is uninitialised that\n"
		"means the variable stopped existing on this step.\n"
		"\n"
		":type: ShaderVariable\n"
		"\n"
		"", (void *) &ShaderVariableChange_after_getset }
,
    { (char *) "before", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value of the variable before the change. If this variable is uninitialised that\n"
		"means the variable came into existance on this step.\n"
		"\n"
		":type: ShaderVariable\n"
		"\n"
		"", (void *) &ShaderVariableChange_before_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderVariableChange_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderVariableChange___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderVariableChange___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderVariableChange_methods[] = {
  { "__eq__", (PyCFunction) _wrap_ShaderVariableChange___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_ShaderVariableChange___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderVariableChange_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderVariableChange",         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderVariableChange_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderVariableChange_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__ShaderVariableChange_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__ShaderVariableChange_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderVariableChange_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "This stores the before and after state of a :class:`ShaderVariable`.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderVariableChange_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderVariableChange_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderVariableChange_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderVariableChange,/* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderVariableChange_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderVariableChange_type};

static SwigPyGetSet ShaderDebugState_callstack_getset = { _wrap_ShaderDebugState_callstack_get, _wrap_ShaderDebugState_callstack_set };
static SwigPyGetSet ShaderDebugState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderDebugState_stepIndex_getset = { _wrap_ShaderDebugState_stepIndex_get, _wrap_ShaderDebugState_stepIndex_set };
static SwigPyGetSet ShaderDebugState_changes_getset = { _wrap_ShaderDebugState_changes_get, _wrap_ShaderDebugState_changes_set };
static SwigPyGetSet ShaderDebugState_flags_getset = { _wrap_ShaderDebugState_flags_get, _wrap_ShaderDebugState_flags_set };
static SwigPyGetSet ShaderDebugState_nextInstruction_getset = { _wrap_ShaderDebugState_nextInstruction_get, _wrap_ShaderDebugState_nextInstruction_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderDebugState_getset[] = {
    { (char *) "callstack", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The function names in the current callstack at this instruction.\n"
		"\n"
		"The oldest/outer function is first in the list, the newest/inner function is last.\n"
		"\n"
		":type: List[str]\n"
		"\n"
		"", (void *) &ShaderDebugState_callstack_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderDebugState.__dict__", (void *) &ShaderDebugState___dict___getset }
,
    { (char *) "stepIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The program counter within the debug trace. The initial state will be index 0, and it\n"
		"will increment linearly after that regardless of loops or branching.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderDebugState_stepIndex_getset }
,
    { (char *) "changes", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The changes in mutable variables for this shader. The change documents the\n"
		"bidirectional change of variables, so that a single state can be updated either forwards or\n"
		"backwards using the information.\n"
		"\n"
		":type: List[ShaderVariableChange]\n"
		"\n"
		"", (void *) &ShaderDebugState_changes_getset }
,
    { (char *) "flags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A set of :class:`ShaderEvents` flags that indicate what events happened on this step.\n"
		"\n"
		":type: ShaderEvents\n"
		"\n"
		"", (void *) &ShaderDebugState_flags_getset }
,
    { (char *) "nextInstruction", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The next instruction to be executed after this state. The initial state before any\n"
		"shader execution happened will have ``nextInstruction == 0``.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderDebugState_nextInstruction_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderDebugState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderDebugState___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderDebugState___lt__(self, other); break;
    case Py_NE : result = _wrap_ShaderDebugState___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderDebugState_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ShaderDebugState___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ShaderDebugState___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_ShaderDebugState___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderDebugState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderDebugState",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderDebugState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderDebugState_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__ShaderDebugState_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__ShaderDebugState_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderDebugState_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"This stores the current state of shader debugging at one particular step in the shader,\n"
		"with all mutable variable contents.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderDebugState_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderDebugState_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderDebugState_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderDebugState,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderDebugState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderDebugState_type};

static SwigPyGetSet ShaderDebugger___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderDebugger_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderDebugger.__dict__", (void *) &ShaderDebugger___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderDebugger_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderDebugger_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderDebugger_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderDebugger",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderDebugger_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderDebugger_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__ShaderDebugger_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__ShaderDebugger_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderDebugger_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "An opaque structure that has internal state for shader debugging",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderDebugger_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderDebugger_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderDebugger_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderDebugger_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderDebugger_type};

static SwigPyGetSet ShaderDebugTrace_constantBlocks_getset = { _wrap_ShaderDebugTrace_constantBlocks_get, _wrap_ShaderDebugTrace_constantBlocks_set };
static SwigPyGetSet ShaderDebugTrace_samplers_getset = { _wrap_ShaderDebugTrace_samplers_get, _wrap_ShaderDebugTrace_samplers_set };
static SwigPyGetSet ShaderDebugTrace_instInfo_getset = { _wrap_ShaderDebugTrace_instInfo_get, _wrap_ShaderDebugTrace_instInfo_set };
static SwigPyGetSet ShaderDebugTrace_stage_getset = { _wrap_ShaderDebugTrace_stage_get, _wrap_ShaderDebugTrace_stage_set };
static SwigPyGetSet ShaderDebugTrace_inputs_getset = { _wrap_ShaderDebugTrace_inputs_get, _wrap_ShaderDebugTrace_inputs_set };
static SwigPyGetSet ShaderDebugTrace___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderDebugTrace_readOnlyResources_getset = { _wrap_ShaderDebugTrace_readOnlyResources_get, _wrap_ShaderDebugTrace_readOnlyResources_set };
static SwigPyGetSet ShaderDebugTrace_readWriteResources_getset = { _wrap_ShaderDebugTrace_readWriteResources_get, _wrap_ShaderDebugTrace_readWriteResources_set };
static SwigPyGetSet ShaderDebugTrace_sourceVars_getset = { _wrap_ShaderDebugTrace_sourceVars_get, _wrap_ShaderDebugTrace_sourceVars_set };
static SwigPyGetSet ShaderDebugTrace_debugger_getset = { _wrap_ShaderDebugTrace_debugger_get, _wrap_ShaderDebugTrace_debugger_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderDebugTrace_getset[] = {
    { (char *) "constantBlocks", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Constant buffer backed variables for this shader.\n"
		"\n"
		"Each entry in this list corresponds to a constant block with the same index in the\n"
		":data:`ShaderReflection.constantBlocks` list, which can be used to look up the metadata.\n"
		"\n"
		"Depending on the underlying shader representation, the constant block may retain any structure or\n"
		"it may have been vectorised and flattened.\n"
		"\n"
		":type: List[ShaderVariable]\n"
		"\n"
		"", (void *) &ShaderDebugTrace_constantBlocks_getset }
,
    { (char *) "samplers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The sampler variables for this shader.\n"
		"\n"
		"The 'value' of the variable is always a single unsigned integer, which is the bindpoint - an index\n"
		"into the :data:`ShaderReflection.samplers` list, which can be used to look up the\n"
		"other metadata as well as find the binding from the pipeline state.\n"
		"\n"
		":type: List[ShaderVariable]\n"
		"\n"
		"", (void *) &ShaderDebugTrace_samplers_getset }
,
    { (char *) "instInfo", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An array of the same size as the number of instructions in the shader, with\n"
		"per-instruction information such as source line mapping, and source variables.\n"
		"\n"
		".. warning::\n"
		"\n"
		"  This array is *not* indexed by instruction. Since it is common for adjacent instructions to have\n"
		"  effectively identical source information, this array only stores unique information ordered by\n"
		"  instruction. On some internal representations this may be one entry per instruction, and on others\n"
		"  it may be sparse and require a binary lookup to locate the corresponding information for an\n"
		"  instruction. If no direct match is found, the lower bound match is valid (i.e. the data for\n"
		"  instruction A before the data for instruction B is valid for all instructions in range ``[A, B)``.\n"
		"\n"
		":type: List[InstructionSourceInfo]\n"
		"\n"
		"", (void *) &ShaderDebugTrace_instInfo_getset }
,
    { (char *) "stage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The shader stage being debugged in this trace\n"
		"\n"
		":type: ShaderStage\n"
		"\n"
		"", (void *) &ShaderDebugTrace_stage_getset }
,
    { (char *) "inputs", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The input variables for this shader.\n"
		"\n"
		":type: List[ShaderVariable]\n"
		"\n"
		"", (void *) &ShaderDebugTrace_inputs_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderDebugTrace.__dict__", (void *) &ShaderDebugTrace___dict___getset }
,
    { (char *) "readOnlyResources", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The read-only resource variables for this shader.\n"
		"\n"
		"The 'value' of the variable is always a single unsigned integer, which is the bindpoint - an index\n"
		"into the :data:`ShaderReflection.readOnlyResources` list, which can be used to look up the\n"
		"other metadata as well as find the binding from the pipeline state.\n"
		"\n"
		":type: List[ShaderVariable]\n"
		"\n"
		"", (void *) &ShaderDebugTrace_readOnlyResources_getset }
,
    { (char *) "readWriteResources", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The read-write resource variables for this shader.\n"
		"\n"
		"The 'value' of the variable is always a single unsigned integer, which is the bindpoint - an index\n"
		"into the :data:`ShaderReflection.readWriteResources` list, which can be used to look up the\n"
		"other metadata as well as find the binding from the pipeline state.\n"
		"\n"
		":type: List[ShaderVariable]\n"
		"\n"
		"", (void *) &ShaderDebugTrace_readWriteResources_getset }
,
    { (char *) "sourceVars", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An optional mapping from high-level source variables to which debug variables and\n"
		"includes extra type information.\n"
		"\n"
		"This list contains source variable mapping that is valid for the lifetime of a debug trace. It may\n"
		"be empty if there is no source variable mapping that extends to the life of the debug trace.\n"
		"\n"
		":type: List[SourceVariableMapping]\n"
		"\n"
		"", (void *) &ShaderDebugTrace_sourceVars_getset }
,
    { (char *) "debugger", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An opaque handle identifying by the underlying debugger, which is used to simulate the\n"
		"shader and generate new debug states.\n"
		"\n"
		"If this is ``None`` then the trace is invalid.\n"
		"\n"
		":type: ShaderDebugger\n"
		"\n"
		"", (void *) &ShaderDebugTrace_debugger_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderDebugTrace_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderDebugTrace_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderDebugTrace_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderDebugTrace",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderDebugTrace_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderDebugTrace_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__ShaderDebugTrace_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__ShaderDebugTrace_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderDebugTrace_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"This stores the whole state of a shader's execution from start to finish, with each\n"
		"individual debugging step along the way, as well as the immutable global constant values that do not\n"
		"change with shader execution.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderDebugTrace_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderDebugTrace_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderDebugTrace_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderDebugTrace,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderDebugTrace_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderDebugTrace_type};

static SwigPyGetSet SigParameter_semanticIndex_getset = { _wrap_SigParameter_semanticIndex_get, _wrap_SigParameter_semanticIndex_set };
static SwigPyGetSet SigParameter_needSemanticIndex_getset = { _wrap_SigParameter_needSemanticIndex_get, _wrap_SigParameter_needSemanticIndex_set };
static SwigPyGetSet SigParameter_channelUsedMask_getset = { _wrap_SigParameter_channelUsedMask_get, _wrap_SigParameter_channelUsedMask_set };
static SwigPyGetSet SigParameter_compCount_getset = { _wrap_SigParameter_compCount_get, _wrap_SigParameter_compCount_set };
static SwigPyGetSet SigParameter_perPrimitiveRate_getset = { _wrap_SigParameter_perPrimitiveRate_get, _wrap_SigParameter_perPrimitiveRate_set };
static SwigPyGetSet SigParameter_semanticName_getset = { _wrap_SigParameter_semanticName_get, _wrap_SigParameter_semanticName_set };
static SwigPyGetSet SigParameter_stream_getset = { _wrap_SigParameter_stream_get, _wrap_SigParameter_stream_set };
static SwigPyGetSet SigParameter_regChannelMask_getset = { _wrap_SigParameter_regChannelMask_get, _wrap_SigParameter_regChannelMask_set };
static SwigPyGetSet SigParameter___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet SigParameter_varName_getset = { _wrap_SigParameter_varName_get, _wrap_SigParameter_varName_set };
static SwigPyGetSet SigParameter_systemValue_getset = { _wrap_SigParameter_systemValue_get, _wrap_SigParameter_systemValue_set };
static SwigPyGetSet SigParameter_regIndex_getset = { _wrap_SigParameter_regIndex_get, _wrap_SigParameter_regIndex_set };
static SwigPyGetSet SigParameter_semanticIdxName_getset = { _wrap_SigParameter_semanticIdxName_get, _wrap_SigParameter_semanticIdxName_set };
static SwigPyGetSet SigParameter_varType_getset = { _wrap_SigParameter_varType_get, _wrap_SigParameter_varType_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__SigParameter_getset[] = {
    { (char *) "semanticIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The semantic index of this variable - see :data:`semanticName`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SigParameter_semanticIndex_getset }
,
    { (char *) "needSemanticIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A convenience flag - ``True`` if the semantic name is unique and no index is needed.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &SigParameter_needSemanticIndex_getset }
,
    { (char *) "channelUsedMask", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A bitmask indicating which components in the shader register are actually used by the\n"
		"shader itself, for APIs that pack signatures together.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SigParameter_channelUsedMask_getset }
,
    { (char *) "compCount", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of components used to store this element. See :data:`varType`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SigParameter_compCount_getset }
,
    { (char *) "perPrimitiveRate", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A flag indicating if this parameter is output at per-primitive rate rather than per-vertex.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &SigParameter_perPrimitiveRate_getset }
,
    { (char *) "semanticName", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The semantic name of this variable, if the API uses semantic matching for bindings.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &SigParameter_semanticName_getset }
,
    { (char *) "stream", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Selects a stream for APIs that provide multiple output streams for the same named output.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SigParameter_stream_getset }
,
    { (char *) "regChannelMask", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A bitmask indicating which components in the shader register are stored, for APIs that\n"
		"pack signatures together.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SigParameter_regChannelMask_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"SigParameter.__dict__", (void *) &SigParameter___dict___getset }
,
    { (char *) "varName", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of this variable - may not be present in the metadata for all APIs.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &SigParameter_varName_getset }
,
    { (char *) "systemValue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ShaderBuiltin` value that this element contains.\n"
		"\n"
		":type: ShaderBuiltin\n"
		"\n"
		"", (void *) &SigParameter_systemValue_getset }
,
    { (char *) "regIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index of the shader register/binding used to store this signature element.\n"
		"\n"
		"This may be :data:`NoIndex` if the element is system-generated and not consumed by another shader\n"
		"stage. See :data:`systemValue`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &SigParameter_regIndex_getset }
,
    { (char *) "semanticIdxName", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The combined semantic name and index.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &SigParameter_semanticIdxName_getset }
,
    { (char *) "varType", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`variable type <VarType>` of data that this element stores.\n"
		"\n"
		":type: VarType\n"
		"\n"
		"", (void *) &SigParameter_varType_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__SigParameter_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_SigParameter___eq__(self, other); break;
    case Py_LT : result = _wrap_SigParameter___lt__(self, other); break;
    case Py_NE : result = _wrap_SigParameter___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__SigParameter_methods[] = {
  { "__lt__", (PyCFunction) _wrap_SigParameter___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_SigParameter___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_SigParameter___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__SigParameter_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.SigParameter",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_SigParameter_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__SigParameter_type.as_number,                  /* tp_as_number */
    &SwigPyBuiltin__SigParameter_type.as_sequence,                /* tp_as_sequence */
    &SwigPyBuiltin__SigParameter_type.as_mapping,                 /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__SigParameter_type.as_buffer,                  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The information describing an input or output signature element describing the interface\n"
		"between shader stages.\n"
		"\n"
		".. data:: NoIndex\n"
		"\n"
		"  Value for an index that means it is invalid or not applicable for this parameter.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__SigParameter_richcompare,        /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__SigParameter_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__SigParameter_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_SigParameter,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__SigParameter_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__SigParameter_type};

static SwigPyGetSet ShaderConstantType_baseType_getset = { _wrap_ShaderConstantType_baseType_get, _wrap_ShaderConstantType_baseType_set };
static SwigPyGetSet ShaderConstantType_name_getset = { _wrap_ShaderConstantType_name_get, _wrap_ShaderConstantType_name_set };
static SwigPyGetSet ShaderConstantType_members_getset = { _wrap_ShaderConstantType_members_get, _wrap_ShaderConstantType_members_set };
static SwigPyGetSet ShaderConstantType_rows_getset = { _wrap_ShaderConstantType_rows_get, _wrap_ShaderConstantType_rows_set };
static SwigPyGetSet ShaderConstantType___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderConstantType_elements_getset = { _wrap_ShaderConstantType_elements_get, _wrap_ShaderConstantType_elements_set };
static SwigPyGetSet ShaderConstantType_arrayByteStride_getset = { _wrap_ShaderConstantType_arrayByteStride_get, _wrap_ShaderConstantType_arrayByteStride_set };
static SwigPyGetSet ShaderConstantType_matrixByteStride_getset = { _wrap_ShaderConstantType_matrixByteStride_get, _wrap_ShaderConstantType_matrixByteStride_set };
static SwigPyGetSet ShaderConstantType_flags_getset = { _wrap_ShaderConstantType_flags_get, _wrap_ShaderConstantType_flags_set };
static SwigPyGetSet ShaderConstantType_pointerTypeID_getset = { _wrap_ShaderConstantType_pointerTypeID_get, _wrap_ShaderConstantType_pointerTypeID_set };
static SwigPyGetSet ShaderConstantType_columns_getset = { _wrap_ShaderConstantType_columns_get, _wrap_ShaderConstantType_columns_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderConstantType_getset[] = {
    { (char *) "baseType", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The base :class:`VarType` of this constant.\n"
		"\n"
		":type: VarType\n"
		"\n"
		"", (void *) &ShaderConstantType_baseType_getset }
,
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of the type of this constant, e.g. a ``struct`` name.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderConstantType_name_getset }
,
    { (char *) "members", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Any members that this constant may contain.\n"
		"\n"
		":type: List[ShaderConstant]\n"
		"\n"
		"", (void *) &ShaderConstantType_members_getset }
,
    { (char *) "rows", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of rows in this matrix.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderConstantType_rows_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderConstantType.__dict__", (void *) &ShaderConstantType___dict___getset }
,
    { (char *) "elements", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of elements in the array, or 1 if it's not an array.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderConstantType_elements_getset }
,
    { (char *) "arrayByteStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of bytes between the start of one element in the array and the next.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderConstantType_arrayByteStride_getset }
,
    { (char *) "matrixByteStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of bytes between the start of one column/row in a matrix and the next.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderConstantType_matrixByteStride_getset }
,
    { (char *) "flags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The flags controlling how this constant is interpreted and displayed.\n"
		"\n"
		":type: ShaderVariableFlags\n"
		"\n"
		"", (void *) &ShaderConstantType_flags_getset }
,
    { (char *) "pointerTypeID", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index in :data:`ShaderReflection.pointerTypes` of the pointee type.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderConstantType_pointerTypeID_getset }
,
    { (char *) "columns", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of columns in this matrix.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderConstantType_columns_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderConstantType_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderConstantType___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderConstantType___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderConstantType_methods[] = {
  { "__eq__", (PyCFunction) _wrap_ShaderConstantType___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_ShaderConstantType___lt__, METH_O, (char *) "__lt__(o)" },
  { "RowMajor", (PyCFunction) _wrap_ShaderConstantType_RowMajor, METH_NOARGS, (char *) "\n"
		"RowMajor()\n"
		"\n"
		"Helper function for checking if :data:`flags` has\n"
		":data:`ShaderVariableFlags.RowMajorMatrix` set. This is entirely equivalent to checking that flag\n"
		"manually, but since it is common this helper is provided.\n"
		"\n"
		".. note::\n"
		"  Vectors and scalars will be marked as row-major by convention for convenience.\n"
		"\n"
		":return: If the storage is row-major order in memory\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "ColMajor", (PyCFunction) _wrap_ShaderConstantType_ColMajor, METH_NOARGS, (char *) "\n"
		"ColMajor()\n"
		"\n"
		"Helper function for checking if :data:`flags` *does not* have\n"
		":data:`ShaderVariableFlags.RowMajorMatrix` set. This is entirely equivalent to checking that flag\n"
		"manually, but since it is common this helper is provided.\n"
		"\n"
		".. note::\n"
		"  Vectors and scalars will be marked as row-major by convention for convenience.\n"
		"\n"
		":return: If the storage is column-major order in memory\n"
		":rtype: bool\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderConstantType_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderConstantType",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderConstantType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderConstantType_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__ShaderConstantType_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__ShaderConstantType_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderConstantType_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the type and members of a :class:`ShaderConstant`.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderConstantType_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderConstantType_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderConstantType_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderConstantType,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderConstantType_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderConstantType_type};

static SwigPyGetSet ShaderConstant_defaultValue_getset = { _wrap_ShaderConstant_defaultValue_get, _wrap_ShaderConstant_defaultValue_set };
static SwigPyGetSet ShaderConstant_name_getset = { _wrap_ShaderConstant_name_get, _wrap_ShaderConstant_name_set };
static SwigPyGetSet ShaderConstant___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderConstant_byteOffset_getset = { _wrap_ShaderConstant_byteOffset_get, _wrap_ShaderConstant_byteOffset_set };
static SwigPyGetSet ShaderConstant_type_getset = { _wrap_ShaderConstant_type_get, _wrap_ShaderConstant_type_set };
static SwigPyGetSet ShaderConstant_bitFieldOffset_getset = { _wrap_ShaderConstant_bitFieldOffset_get, _wrap_ShaderConstant_bitFieldOffset_set };
static SwigPyGetSet ShaderConstant_bitFieldSize_getset = { _wrap_ShaderConstant_bitFieldSize_get, _wrap_ShaderConstant_bitFieldSize_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderConstant_getset[] = {
    { (char *) "defaultValue", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If this constant is no larger than a 64-bit constant, gives a default value for it.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderConstant_defaultValue_getset }
,
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of this constant\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderConstant_name_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderConstant.__dict__", (void *) &ShaderConstant___dict___getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset of this constant relative to the parent structure\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderConstant_byteOffset_getset }
,
    { (char *) "type", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The type information for this constant.\n"
		"\n"
		":type: ShaderConstantType\n"
		"\n"
		"", (void *) &ShaderConstant_type_getset }
,
    { (char *) "bitFieldOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If the variable is bitfield packed, the bit offset from :data:`byteOffset` above where\n"
		"this variable starts.\n"
		"\n"
		"If the variable is not a bitfield, this value will be 0. Only integer scalars will have bitfield\n"
		"packing.\n"
		"\n"
		".. note::\n"
		"   Although the offset specified in :data:`byteOffset` is in bytes, this bitfield offset may be\n"
		"   larger than 0 depending on the surrounding values and their types and packing. However it is\n"
		"   guaranteed that the offset and the size (from :data:`bitFieldSize`) will be contained within the\n"
		"   normal bit size for the variable type. For example if the variable type is a 32-bit integer, the\n"
		"   offsets may range from 0 to 31 and the sum of offset and size will be no more than 32. If the\n"
		"   variable is an 8-bit integer, similarly the offset will be 0 to 7 and the sum will be no more\n"
		"   than 8.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderConstant_bitFieldOffset_getset }
,
    { (char *) "bitFieldSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If the variable is bitfield packed, the number of bits this variable spans starting\n"
		"from :data:`bitFieldOffset` into memory.\n"
		"\n"
		"If the variable is not a bitfield, this value will be 0. Only integer scalars will have bitfield\n"
		"packing.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderConstant_bitFieldSize_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderConstant_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderConstant___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderConstant___lt__(self, other); break;
    case Py_NE : result = _wrap_ShaderConstant___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderConstant_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ShaderConstant___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ShaderConstant___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_ShaderConstant___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderConstant_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderConstant",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderConstant_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderConstant_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__ShaderConstant_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__ShaderConstant_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderConstant_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Contains the detail of a constant within a struct, such as a :class:`ConstantBlock`,\n"
		"with its type and relative location in memory.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderConstant_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderConstant_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderConstant_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderConstant,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderConstant_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderConstant_type};

static SwigPyGetSet ConstantBlock_bindArraySize_getset = { _wrap_ConstantBlock_bindArraySize_get, _wrap_ConstantBlock_bindArraySize_set };
static SwigPyGetSet ConstantBlock_bufferBacked_getset = { _wrap_ConstantBlock_bufferBacked_get, _wrap_ConstantBlock_bufferBacked_set };
static SwigPyGetSet ConstantBlock_name_getset = { _wrap_ConstantBlock_name_get, _wrap_ConstantBlock_name_set };
static SwigPyGetSet ConstantBlock_inlineDataBytes_getset = { _wrap_ConstantBlock_inlineDataBytes_get, _wrap_ConstantBlock_inlineDataBytes_set };
static SwigPyGetSet ConstantBlock_variables_getset = { _wrap_ConstantBlock_variables_get, _wrap_ConstantBlock_variables_set };
static SwigPyGetSet ConstantBlock_fixedBindNumber_getset = { _wrap_ConstantBlock_fixedBindNumber_get, _wrap_ConstantBlock_fixedBindNumber_set };
static SwigPyGetSet ConstantBlock___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ConstantBlock_compileConstants_getset = { _wrap_ConstantBlock_compileConstants_get, _wrap_ConstantBlock_compileConstants_set };
static SwigPyGetSet ConstantBlock_fixedBindSetOrSpace_getset = { _wrap_ConstantBlock_fixedBindSetOrSpace_get, _wrap_ConstantBlock_fixedBindSetOrSpace_set };
static SwigPyGetSet ConstantBlock_byteSize_getset = { _wrap_ConstantBlock_byteSize_get, _wrap_ConstantBlock_byteSize_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ConstantBlock_getset[] = {
    { (char *) "bindArraySize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If this binding is natively arrayed, how large is the array size. If not arrayed, this\n"
		"will be set to 1.\n"
		"\n"
		"This value may be set to a very large number if the array is unbounded in the shader.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ConstantBlock_bindArraySize_getset }
,
    { (char *) "bufferBacked", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the contents are stored in a buffer of memory. If not then they are set by\n"
		"some other API-specific method, such as direct function calls or they may be compile-time\n"
		"specialisation constants.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &ConstantBlock_bufferBacked_getset }
,
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of this constant block, may be empty on some APIs.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ConstantBlock_name_getset }
,
    { (char *) "inlineDataBytes", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this is backed by in-line data bytes rather than a specific buffer.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &ConstantBlock_inlineDataBytes_getset }
,
    { (char *) "variables", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The constants contained within this block.\n"
		"\n"
		":type: List[ShaderConstant]\n"
		"\n"
		"", (void *) &ConstantBlock_variables_getset }
,
    { (char *) "fixedBindNumber", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed binding number for this binding. The interpretation of this is API-specific\n"
		"and it is provided purely for informational purposes and has no bearing on how data is accessed or\n"
		"described. Similarly some bindings don't have a fixed bind number and the value here should not be\n"
		"relied on.\n"
		"\n"
		"For OpenGL only, this value is not used as bindings are dynamic and cannot be determined by the\n"
		"shader reflection. Bindings must be determined only by the descriptor mapped to.\n"
		"\n"
		"Generally speaking sorting by this number will give a reasonable ordering by binding if it exists.\n"
		"\n"
		".. note::\n"
		"  Because this number is API-specific, there is no guarantee that it will be unique across all\n"
		"  resources, though generally it will be unique within all binds of the same type. It should be used\n"
		"  only within contexts that can interpret it API-specifically, or else for purely\n"
		"  informational/non-semantic purposes like sorting.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ConstantBlock_fixedBindNumber_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ConstantBlock.__dict__", (void *) &ConstantBlock___dict___getset }
,
    { (char *) "compileConstants", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this is a virtual buffer listing compile-time specialisation constants.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &ConstantBlock_compileConstants_getset }
,
    { (char *) "fixedBindSetOrSpace", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed binding set or space for this binding. This is API-specific, on Vulkan this\n"
		"gives the set and on D3D12 this gives the register space.\n"
		"It is provided purely for informational purposes and has no bearing on how data is accessed or\n"
		"described.\n"
		"\n"
		"Generally speaking sorting by this number before :data:`fixedBindNumber` will give a reasonable\n"
		"ordering by binding if it exists.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ConstantBlock_fixedBindSetOrSpace_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The total number of bytes consumed by all of the constants contained in this block.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ConstantBlock_byteSize_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ConstantBlock_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ConstantBlock___eq__(self, other); break;
    case Py_LT : result = _wrap_ConstantBlock___lt__(self, other); break;
    case Py_NE : result = _wrap_ConstantBlock___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ConstantBlock_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ConstantBlock___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ConstantBlock___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_ConstantBlock___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ConstantBlock_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ConstantBlock",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ConstantBlock_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ConstantBlock_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__ConstantBlock_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__ConstantBlock_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ConstantBlock_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Contains the information for a block of constant values. The values are not present,\n"
		"only the metadata about how the variables are stored in memory itself and their type/name\n"
		"information.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ConstantBlock_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ConstantBlock_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ConstantBlock_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ConstantBlock,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ConstantBlock_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ConstantBlock_type};

static SwigPyGetSet ShaderSampler_bindArraySize_getset = { _wrap_ShaderSampler_bindArraySize_get, _wrap_ShaderSampler_bindArraySize_set };
static SwigPyGetSet ShaderSampler_name_getset = { _wrap_ShaderSampler_name_get, _wrap_ShaderSampler_name_set };
static SwigPyGetSet ShaderSampler_fixedBindNumber_getset = { _wrap_ShaderSampler_fixedBindNumber_get, _wrap_ShaderSampler_fixedBindNumber_set };
static SwigPyGetSet ShaderSampler___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderSampler_fixedBindSetOrSpace_getset = { _wrap_ShaderSampler_fixedBindSetOrSpace_get, _wrap_ShaderSampler_fixedBindSetOrSpace_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderSampler_getset[] = {
    { (char *) "bindArraySize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If this binding is natively arrayed, how large is the array size. If not arrayed, this\n"
		"will be set to 1.\n"
		"\n"
		"This value may be set to a very large number if the array is unbounded in the shader.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderSampler_bindArraySize_getset }
,
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of this sampler.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderSampler_name_getset }
,
    { (char *) "fixedBindNumber", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed binding number for this binding. The interpretation of this is API-specific\n"
		"and it is provided purely for informational purposes and has no bearing on how data is accessed or\n"
		"described. Similarly some bindings don't have a fixed bind number and the value here should not be\n"
		"relied on.\n"
		"\n"
		"For OpenGL only, this value is not used as bindings are dynamic and cannot be determined by the\n"
		"shader reflection. Bindings must be determined only by the descriptor mapped to.\n"
		"\n"
		"Generally speaking sorting by this number will give a reasonable ordering by binding if it exists.\n"
		"\n"
		".. note::\n"
		"  Because this number is API-specific, there is no guarantee that it will be unique across all\n"
		"  resources, though generally it will be unique within all binds of the same type. It should be used\n"
		"  only within contexts that can interpret it API-specifically, or else for purely\n"
		"  informational/non-semantic purposes like sorting.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderSampler_fixedBindNumber_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderSampler.__dict__", (void *) &ShaderSampler___dict___getset }
,
    { (char *) "fixedBindSetOrSpace", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed binding set or space for this binding. This is API-specific, on Vulkan this\n"
		"gives the set and on D3D12 this gives the register space.\n"
		"It is provided purely for informational purposes and has no bearing on how data is accessed or\n"
		"described.\n"
		"\n"
		"Generally speaking sorting by this number before :data:`fixedBindNumber` will give a reasonable\n"
		"ordering by binding if it exists.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderSampler_fixedBindSetOrSpace_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderSampler_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderSampler___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderSampler___lt__(self, other); break;
    case Py_NE : result = _wrap_ShaderSampler___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderSampler_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ShaderSampler___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ShaderSampler___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_ShaderSampler___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderSampler_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderSampler",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderSampler_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderSampler_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__ShaderSampler_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__ShaderSampler_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderSampler_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Contains the information for a separate sampler in a shader. If the API doesn't have\n"
		"the concept of separate samplers, this struct will be unused and only :class:`ShaderResource` is\n"
		"relevant.\n"
		"\n"
		".. note:: that constant blocks will not have a shader resource entry, see :class:`ConstantBlock`.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderSampler_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderSampler_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderSampler_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderSampler,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderSampler_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderSampler_type};

static SwigPyGetSet ShaderResource_bindArraySize_getset = { _wrap_ShaderResource_bindArraySize_get, _wrap_ShaderResource_bindArraySize_set };
static SwigPyGetSet ShaderResource_name_getset = { _wrap_ShaderResource_name_get, _wrap_ShaderResource_name_set };
static SwigPyGetSet ShaderResource_hasSampler_getset = { _wrap_ShaderResource_hasSampler_get, _wrap_ShaderResource_hasSampler_set };
static SwigPyGetSet ShaderResource_fixedBindNumber_getset = { _wrap_ShaderResource_fixedBindNumber_get, _wrap_ShaderResource_fixedBindNumber_set };
static SwigPyGetSet ShaderResource_isReadOnly_getset = { _wrap_ShaderResource_isReadOnly_get, _wrap_ShaderResource_isReadOnly_set };
static SwigPyGetSet ShaderResource___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderResource_descriptorType_getset = { _wrap_ShaderResource_descriptorType_get, _wrap_ShaderResource_descriptorType_set };
static SwigPyGetSet ShaderResource_isInputAttachment_getset = { _wrap_ShaderResource_isInputAttachment_get, _wrap_ShaderResource_isInputAttachment_set };
static SwigPyGetSet ShaderResource_fixedBindSetOrSpace_getset = { _wrap_ShaderResource_fixedBindSetOrSpace_get, _wrap_ShaderResource_fixedBindSetOrSpace_set };
static SwigPyGetSet ShaderResource_isTexture_getset = { _wrap_ShaderResource_isTexture_get, _wrap_ShaderResource_isTexture_set };
static SwigPyGetSet ShaderResource_textureType_getset = { _wrap_ShaderResource_textureType_get, _wrap_ShaderResource_textureType_set };
static SwigPyGetSet ShaderResource_variableType_getset = { _wrap_ShaderResource_variableType_get, _wrap_ShaderResource_variableType_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderResource_getset[] = {
    { (char *) "bindArraySize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If this binding is natively arrayed, how large is the array size. If not arrayed, this\n"
		"will be set to 1.\n"
		"\n"
		"This value may be set to a very large number if the array is unbounded in the shader.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderResource_bindArraySize_getset }
,
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of this resource.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderResource_name_getset }
,
    { (char *) "hasSampler", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this texture resource has a sampler as well.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &ShaderResource_hasSampler_getset }
,
    { (char *) "fixedBindNumber", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed binding number for this binding. The interpretation of this is API-specific\n"
		"and it is provided purely for informational purposes and has no bearing on how data is accessed or\n"
		"described. Similarly some bindings don't have a fixed bind number and the value here should not be\n"
		"relied on.\n"
		"\n"
		"For OpenGL only, this value is not used as bindings are dynamic and cannot be determined by the\n"
		"shader reflection. Bindings must be determined only by the descriptor mapped to.\n"
		"\n"
		"Generally speaking sorting by this number will give a reasonable ordering by binding if it exists.\n"
		"\n"
		".. note::\n"
		"  Because this number is API-specific, there is no guarantee that it will be unique across all\n"
		"  resources, though generally it will be unique within all binds of the same type. It should be used\n"
		"  only within contexts that can interpret it API-specifically, or else for purely\n"
		"  informational/non-semantic purposes like sorting.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderResource_fixedBindNumber_getset }
,
    { (char *) "isReadOnly", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this resource is available to the shader for reading only, otherwise it is\n"
		"able to be read from and written to arbitrarily.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &ShaderResource_isReadOnly_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderResource.__dict__", (void *) &ShaderResource___dict___getset }
,
    { (char *) "descriptorType", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`DescriptorType` which this resource expects to access.\n"
		"\n"
		":type: DescriptorType\n"
		"\n"
		"", (void *) &ShaderResource_descriptorType_getset }
,
    { (char *) "isInputAttachment", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this texture resource is a subpass input attachment.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &ShaderResource_isInputAttachment_getset }
,
    { (char *) "fixedBindSetOrSpace", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed binding set or space for this binding. This is API-specific, on Vulkan this\n"
		"gives the set and on D3D12 this gives the register space.\n"
		"It is provided purely for informational purposes and has no bearing on how data is accessed or\n"
		"described.\n"
		"\n"
		"Generally speaking sorting by this number before :data:`fixedBindNumber` will give a reasonable\n"
		"ordering by binding if it exists.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderResource_fixedBindSetOrSpace_getset }
,
    { (char *) "isTexture", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if this resource is a texture, otherwise it is a buffer.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &ShaderResource_isTexture_getset }
,
    { (char *) "textureType", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`TextureType` that describes the type of this resource.\n"
		"\n"
		":type: TextureType\n"
		"\n"
		"", (void *) &ShaderResource_textureType_getset }
,
    { (char *) "variableType", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The type of each element of this resource.\n"
		"\n"
		":type: ShaderConstantType\n"
		"\n"
		"", (void *) &ShaderResource_variableType_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderResource_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderResource___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderResource___lt__(self, other); break;
    case Py_NE : result = _wrap_ShaderResource___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderResource_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ShaderResource___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ShaderResource___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_ShaderResource___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderResource_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderResource",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderResource_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderResource_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__ShaderResource_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__ShaderResource_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderResource_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Contains the information for a shader resource that is made accessible to shaders\n"
		"directly by means of the API resource binding system.\n"
		"\n"
		".. note:: that constant blocks and samplers will not have a shader resource entry, see\n"
		"  :class:`ConstantBlock` and :class:`ShaderSampler`.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderResource_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderResource_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderResource_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderResource,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderResource_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderResource_type};

static SwigPyGetSet ShaderEntryPoint_name_getset = { _wrap_ShaderEntryPoint_name_get, _wrap_ShaderEntryPoint_name_set };
static SwigPyGetSet ShaderEntryPoint_stage_getset = { _wrap_ShaderEntryPoint_stage_get, _wrap_ShaderEntryPoint_stage_set };
static SwigPyGetSet ShaderEntryPoint___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderEntryPoint_getset[] = {
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of the entry point.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderEntryPoint_name_getset }
,
    { (char *) "stage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ShaderStage` for this entry point .\n"
		"\n"
		":type: ShaderStage\n"
		"\n"
		"", (void *) &ShaderEntryPoint_stage_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderEntryPoint.__dict__", (void *) &ShaderEntryPoint___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderEntryPoint_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderEntryPoint___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderEntryPoint___lt__(self, other); break;
    case Py_NE : result = _wrap_ShaderEntryPoint___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderEntryPoint_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ShaderEntryPoint___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ShaderEntryPoint___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_ShaderEntryPoint___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderEntryPoint_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderEntryPoint",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderEntryPoint_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderEntryPoint_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__ShaderEntryPoint_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__ShaderEntryPoint_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderEntryPoint_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes an entry point in a shader.",  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderEntryPoint_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderEntryPoint_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderEntryPoint_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderEntryPoint,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderEntryPoint_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderEntryPoint_type};

static SwigPyGetSet ShaderCompileFlag_value_getset = { _wrap_ShaderCompileFlag_value_get, _wrap_ShaderCompileFlag_value_set };
static SwigPyGetSet ShaderCompileFlag_name_getset = { _wrap_ShaderCompileFlag_name_get, _wrap_ShaderCompileFlag_name_set };
static SwigPyGetSet ShaderCompileFlag___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderCompileFlag_getset[] = {
    { (char *) "value", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The value of the compile flag.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderCompileFlag_value_getset }
,
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of the compile flag.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderCompileFlag_name_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderCompileFlag.__dict__", (void *) &ShaderCompileFlag___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderCompileFlag_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderCompileFlag___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderCompileFlag___lt__(self, other); break;
    case Py_NE : result = _wrap_ShaderCompileFlag___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderCompileFlag_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ShaderCompileFlag___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ShaderCompileFlag___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_ShaderCompileFlag___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderCompileFlag_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderCompileFlag",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderCompileFlag_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderCompileFlag_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__ShaderCompileFlag_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__ShaderCompileFlag_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderCompileFlag_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains a single flag used at compile-time on a shader.",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderCompileFlag_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderCompileFlag_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderCompileFlag_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderCompileFlag,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderCompileFlag_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderCompileFlag_type};

static SwigPyGetSet ShaderCompileFlags___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderCompileFlags_flags_getset = { _wrap_ShaderCompileFlags_flags_get, _wrap_ShaderCompileFlags_flags_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderCompileFlags_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderCompileFlags.__dict__", (void *) &ShaderCompileFlags___dict___getset }
,
    { (char *) "flags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The API or compiler specific flags used to compile this shader originally.\n"
		"\n"
		":type: List[ShaderCompileFlag]\n"
		"\n"
		"", (void *) &ShaderCompileFlags_flags_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderCompileFlags_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderCompileFlags_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderCompileFlags_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderCompileFlags",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderCompileFlags_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderCompileFlags_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__ShaderCompileFlags_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__ShaderCompileFlags_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderCompileFlags_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the information about the compilation environment of a shader",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderCompileFlags_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderCompileFlags_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderCompileFlags_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderCompileFlags,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderCompileFlags_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderCompileFlags_type};

static SwigPyGetSet ShaderSourcePrefix_prefix_getset = { _wrap_ShaderSourcePrefix_prefix_get, _wrap_ShaderSourcePrefix_prefix_set };
static SwigPyGetSet ShaderSourcePrefix_encoding_getset = { _wrap_ShaderSourcePrefix_encoding_get, _wrap_ShaderSourcePrefix_encoding_set };
static SwigPyGetSet ShaderSourcePrefix___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderSourcePrefix_getset[] = {
    { (char *) "prefix", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The source prefix to add.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderSourcePrefix_prefix_getset }
,
    { (char *) "encoding", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The encoding of the language this prefix applies to.\n"
		"\n"
		":type: ShaderEncoding\n"
		"\n"
		"", (void *) &ShaderSourcePrefix_encoding_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderSourcePrefix.__dict__", (void *) &ShaderSourcePrefix___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderSourcePrefix_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderSourcePrefix___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderSourcePrefix___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderSourcePrefix_methods[] = {
  { "__eq__", (PyCFunction) _wrap_ShaderSourcePrefix___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_ShaderSourcePrefix___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderSourcePrefix_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderSourcePrefix",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderSourcePrefix_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderSourcePrefix_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__ShaderSourcePrefix_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__ShaderSourcePrefix_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderSourcePrefix_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the source prefix to add to a given type of shader source",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderSourcePrefix_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderSourcePrefix_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderSourcePrefix_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderSourcePrefix,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderSourcePrefix_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderSourcePrefix_type};

static SwigPyGetSet ShaderSourceFile_contents_getset = { _wrap_ShaderSourceFile_contents_get, _wrap_ShaderSourceFile_contents_set };
static SwigPyGetSet ShaderSourceFile___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderSourceFile_filename_getset = { _wrap_ShaderSourceFile_filename_get, _wrap_ShaderSourceFile_filename_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderSourceFile_getset[] = {
    { (char *) "contents", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The actual contents of the file.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderSourceFile_contents_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderSourceFile.__dict__", (void *) &ShaderSourceFile___dict___getset }
,
    { (char *) "filename", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The filename of this source file.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderSourceFile_filename_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderSourceFile_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_ShaderSourceFile___eq__(self, other); break;
    case Py_LT : result = _wrap_ShaderSourceFile___lt__(self, other); break;
    case Py_NE : result = _wrap_ShaderSourceFile___ne__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderSourceFile_methods[] = {
  { "__lt__", (PyCFunction) _wrap_ShaderSourceFile___lt__, METH_O, (char *) "__lt__(o)" },
  { "__eq__", (PyCFunction) _wrap_ShaderSourceFile___eq__, METH_O, (char *) "__eq__(other)" },
  { "__ne__", (PyCFunction) _wrap_ShaderSourceFile___ne__, METH_O, (char *) "__ne__(other)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderSourceFile_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderSourceFile",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderSourceFile_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderSourceFile_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__ShaderSourceFile_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__ShaderSourceFile_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderSourceFile_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains a source file available in a debug-compiled shader.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderSourceFile_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderSourceFile_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderSourceFile_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderSourceFile,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderSourceFile_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderSourceFile_type};

static SwigPyGetSet ShaderDebugInfo_sourceDebugInformation_getset = { _wrap_ShaderDebugInfo_sourceDebugInformation_get, _wrap_ShaderDebugInfo_sourceDebugInformation_set };
static SwigPyGetSet ShaderDebugInfo_entryLocation_getset = { _wrap_ShaderDebugInfo_entryLocation_get, _wrap_ShaderDebugInfo_entryLocation_set };
static SwigPyGetSet ShaderDebugInfo_editBaseFile_getset = { _wrap_ShaderDebugInfo_editBaseFile_get, _wrap_ShaderDebugInfo_editBaseFile_set };
static SwigPyGetSet ShaderDebugInfo_encoding_getset = { _wrap_ShaderDebugInfo_encoding_get, _wrap_ShaderDebugInfo_encoding_set };
static SwigPyGetSet ShaderDebugInfo___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderDebugInfo_entrySourceName_getset = { _wrap_ShaderDebugInfo_entrySourceName_get, _wrap_ShaderDebugInfo_entrySourceName_set };
static SwigPyGetSet ShaderDebugInfo_debuggable_getset = { _wrap_ShaderDebugInfo_debuggable_get, _wrap_ShaderDebugInfo_debuggable_set };
static SwigPyGetSet ShaderDebugInfo_compiler_getset = { _wrap_ShaderDebugInfo_compiler_get, _wrap_ShaderDebugInfo_compiler_set };
static SwigPyGetSet ShaderDebugInfo_debugInfoLoadingLog_getset = { _wrap_ShaderDebugInfo_debugInfoLoadingLog_get, _wrap_ShaderDebugInfo_debugInfoLoadingLog_set };
static SwigPyGetSet ShaderDebugInfo_debugStatus_getset = { _wrap_ShaderDebugInfo_debugStatus_get, _wrap_ShaderDebugInfo_debugStatus_set };
static SwigPyGetSet ShaderDebugInfo_compileFlags_getset = { _wrap_ShaderDebugInfo_compileFlags_get, _wrap_ShaderDebugInfo_compileFlags_set };
static SwigPyGetSet ShaderDebugInfo_files_getset = { _wrap_ShaderDebugInfo_files_get, _wrap_ShaderDebugInfo_files_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderDebugInfo_getset[] = {
    { (char *) "sourceDebugInformation", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Indicates whether this shader has debug information to allow source-level debugging.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &ShaderDebugInfo_sourceDebugInformation_getset }
,
    { (char *) "entryLocation", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The source location of the first executable line or the entry point.\n"
		"\n"
		".. note::\n"
		"\n"
		"  The information is not guaranteed to be available depending on the underlying shader format, so\n"
		"  all of the elements are optional.\n"
		"\n"
		":type: LineColumnInfo\n"
		"\n"
		"", (void *) &ShaderDebugInfo_entryLocation_getset }
,
    { (char *) "editBaseFile", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index of the file which should be used for re-editing this shader's entry point.\n"
		"\n"
		"This is an optional value, and if set to ``-1`` you should fall back to using the file specified\n"
		"in :data:`entryLocation`, and if no file is specified there then use the first file listed.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &ShaderDebugInfo_editBaseFile_getset }
,
    { (char *) "encoding", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ShaderEncoding` of the source. See :data:`files`.\n"
		"\n"
		":type: ShaderEncoding\n"
		"\n"
		"", (void *) &ShaderDebugInfo_encoding_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderDebugInfo.__dict__", (void *) &ShaderDebugInfo___dict___getset }
,
    { (char *) "entrySourceName", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of the entry point in the source code, not necessarily the same as the\n"
		"entry point name exported to the API.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderDebugInfo_entrySourceName_getset }
,
    { (char *) "debuggable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Indicates whether this particular shader can be debugged. In some cases even if the\n"
		"API can debug shaders in general, specific shaders cannot be debugged because they use unsupported\n"
		"functionality\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &ShaderDebugInfo_debuggable_getset }
,
    { (char *) "compiler", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`KnownShaderTool` of the compiling tool.\n"
		"\n"
		":type: KnownShaderTool\n"
		"\n"
		"", (void *) &ShaderDebugInfo_compiler_getset }
,
    { (char *) "debugInfoLoadingLog", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Contains a log of the debug shader loading process i.e. searching for shader PDB.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderDebugInfo_debugInfoLoadingLog_getset }
,
    { (char *) "debugStatus", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If :data:`debuggable` is false then this contains a simple explanation of why the\n"
		"shader is not supported for debugging\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderDebugInfo_debugStatus_getset }
,
    { (char *) "compileFlags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The flags used to compile this shader.\n"
		"\n"
		":type: ShaderCompileFlags\n"
		"\n"
		"", (void *) &ShaderDebugInfo_compileFlags_getset }
,
    { (char *) "files", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The shader files encoded in the form denoted by :data:`encoding`.\n"
		"\n"
		"The first entry in the list is always the file where the entry point is.\n"
		"\n"
		":type: List[ShaderSourceFile]\n"
		"\n"
		"", (void *) &ShaderDebugInfo_files_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderDebugInfo_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderDebugInfo_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderDebugInfo_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderDebugInfo",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderDebugInfo_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderDebugInfo_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__ShaderDebugInfo_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__ShaderDebugInfo_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderDebugInfo_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Contains the information about a shader contained within API-specific debugging\n"
		"information attached to the shader.\n"
		"\n"
		"Primarily this means the embedded original source files.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderDebugInfo_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderDebugInfo_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderDebugInfo_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderDebugInfo,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderDebugInfo_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderDebugInfo_type};

static SwigPyGetSet ShaderReflection_rawBytes_getset = { _wrap_ShaderReflection_rawBytes_get, _wrap_ShaderReflection_rawBytes_set };
static SwigPyGetSet ShaderReflection_dispatchThreadsDimension_getset = { _wrap_ShaderReflection_dispatchThreadsDimension_get, _wrap_ShaderReflection_dispatchThreadsDimension_set };
static SwigPyGetSet ShaderReflection_constantBlocks_getset = { _wrap_ShaderReflection_constantBlocks_get, _wrap_ShaderReflection_constantBlocks_set };
static SwigPyGetSet ShaderReflection_rayAttributes_getset = { _wrap_ShaderReflection_rayAttributes_get, _wrap_ShaderReflection_rayAttributes_set };
static SwigPyGetSet ShaderReflection_resourceId_getset = { _wrap_ShaderReflection_resourceId_get, _wrap_ShaderReflection_resourceId_set };
static SwigPyGetSet ShaderReflection_debugInfo_getset = { _wrap_ShaderReflection_debugInfo_get, _wrap_ShaderReflection_debugInfo_set };
static SwigPyGetSet ShaderReflection_samplers_getset = { _wrap_ShaderReflection_samplers_get, _wrap_ShaderReflection_samplers_set };
static SwigPyGetSet ShaderReflection_stage_getset = { _wrap_ShaderReflection_stage_get, _wrap_ShaderReflection_stage_set };
static SwigPyGetSet ShaderReflection_entryPoint_getset = { _wrap_ShaderReflection_entryPoint_get, _wrap_ShaderReflection_entryPoint_set };
static SwigPyGetSet ShaderReflection_encoding_getset = { _wrap_ShaderReflection_encoding_get, _wrap_ShaderReflection_encoding_set };
static SwigPyGetSet ShaderReflection___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet ShaderReflection_inputSignature_getset = { _wrap_ShaderReflection_inputSignature_get, _wrap_ShaderReflection_inputSignature_set };
static SwigPyGetSet ShaderReflection_outputSignature_getset = { _wrap_ShaderReflection_outputSignature_get, _wrap_ShaderReflection_outputSignature_set };
static SwigPyGetSet ShaderReflection_readOnlyResources_getset = { _wrap_ShaderReflection_readOnlyResources_get, _wrap_ShaderReflection_readOnlyResources_set };
static SwigPyGetSet ShaderReflection_readWriteResources_getset = { _wrap_ShaderReflection_readWriteResources_get, _wrap_ShaderReflection_readWriteResources_set };
static SwigPyGetSet ShaderReflection_pointerTypes_getset = { _wrap_ShaderReflection_pointerTypes_get, _wrap_ShaderReflection_pointerTypes_set };
static SwigPyGetSet ShaderReflection_taskPayload_getset = { _wrap_ShaderReflection_taskPayload_get, _wrap_ShaderReflection_taskPayload_set };
static SwigPyGetSet ShaderReflection_rayPayload_getset = { _wrap_ShaderReflection_rayPayload_get, _wrap_ShaderReflection_rayPayload_set };
static SwigPyGetSet ShaderReflection_outputTopology_getset = { _wrap_ShaderReflection_outputTopology_get, _wrap_ShaderReflection_outputTopology_set };
static SwigPyGetSet ShaderReflection_interfaces_getset = { _wrap_ShaderReflection_interfaces_get, _wrap_ShaderReflection_interfaces_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__ShaderReflection_getset[] = {
    { (char *) "rawBytes", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A raw ``bytes`` dump of the original shader, encoded in the form denoted by\n"
		":data:`encoding`.\n"
		"\n"
		":type: bytes\n"
		"\n"
		"", (void *) &ShaderReflection_rawBytes_getset }
,
    { (char *) "dispatchThreadsDimension", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The 3D dimensions of a compute workgroup, for compute shaders.\n"
		"\n"
		":type: Tuple[int,int,int]\n"
		"\n"
		"", (void *) &ShaderReflection_dispatchThreadsDimension_getset }
,
    { (char *) "constantBlocks", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The constant block bindings.\n"
		"\n"
		":type: List[ConstantBlock]\n"
		"\n"
		"", (void *) &ShaderReflection_constantBlocks_getset }
,
    { (char *) "rayAttributes", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The block layout of the ray attributes structure.\n"
		"\n"
		"Only relevant for intersection shaders and closest/any hit shaders, this gives\n"
		"the attributes structure produced by a custom intersection shader which is available by hit shaders,\n"
		"or else the built-in structure if no intersection shader was used and a triangle intersection is\n"
		"reported.\n"
		"\n"
		":type: ConstantBlock\n"
		"\n"
		"", (void *) &ShaderReflection_rayAttributes_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of this shader.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &ShaderReflection_resourceId_getset }
,
    { (char *) "debugInfo", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The embedded debugging information.\n"
		"\n"
		":type: ShaderDebugInfo\n"
		"\n"
		"", (void *) &ShaderReflection_debugInfo_getset }
,
    { (char *) "samplers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The sampler bindings.\n"
		"\n"
		":type: List[ShaderSampler]\n"
		"\n"
		"", (void *) &ShaderReflection_samplers_getset }
,
    { (char *) "stage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ShaderStage` that this shader corresponds to, if multiple entry points exist.\n"
		"\n"
		":type: ShaderStage\n"
		"\n"
		"", (void *) &ShaderReflection_stage_getset }
,
    { (char *) "entryPoint", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The entry point in the shader for this reflection, if multiple entry points exist.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &ShaderReflection_entryPoint_getset }
,
    { (char *) "encoding", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ShaderEncoding` of this shader. See :data:`rawBytes`.\n"
		"\n"
		":type: ShaderEncoding\n"
		"\n"
		"", (void *) &ShaderReflection_encoding_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"ShaderReflection.__dict__", (void *) &ShaderReflection___dict___getset }
,
    { (char *) "inputSignature", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The input signature.\n"
		"\n"
		":type: List[SigParameter]\n"
		"\n"
		"", (void *) &ShaderReflection_inputSignature_getset }
,
    { (char *) "outputSignature", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The output signature.\n"
		"\n"
		":type: List[SigParameter]\n"
		"\n"
		"", (void *) &ShaderReflection_outputSignature_getset }
,
    { (char *) "readOnlyResources", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The read-only resource bindings.\n"
		"\n"
		":type: List[ShaderResource]\n"
		"\n"
		"", (void *) &ShaderReflection_readOnlyResources_getset }
,
    { (char *) "readWriteResources", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The read-write resource bindings.\n"
		"\n"
		":type: List[ShaderResource]\n"
		"\n"
		"", (void *) &ShaderReflection_readWriteResources_getset }
,
    { (char *) "pointerTypes", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The list of pointer types referred to in this shader.\n"
		"\n"
		":type: List[ShaderConstantType]\n"
		"\n"
		"", (void *) &ShaderReflection_pointerTypes_getset }
,
    { (char *) "taskPayload", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The block layout of the task-mesh communication payload.\n"
		"\n"
		"Only relevant for task or mesh shaders, this gives the output payload (for task shaders) or the\n"
		"input payload (for mesh shaders)\n"
		"\n"
		":type: ConstantBlock\n"
		"\n"
		"", (void *) &ShaderReflection_taskPayload_getset }
,
    { (char *) "rayPayload", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The block layout of the ray payload.\n"
		"\n"
		"Only relevant for raytracing shaders, this gives the payload accessible for read and write by ray\n"
		"evaluation during the processing of the ray\n"
		"\n"
		":type: ConstantBlock\n"
		"\n"
		"", (void *) &ShaderReflection_rayPayload_getset }
,
    { (char *) "outputTopology", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The output topology for geometry, tessellation and mesh shaders.\n"
		"\n"
		":type: Topology\n"
		"\n"
		"", (void *) &ShaderReflection_outputTopology_getset }
,
    { (char *) "interfaces", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The list of strings with the shader's interfaces. Largely an unused API feature.\n"
		"\n"
		":type: List[str]\n"
		"\n"
		"", (void *) &ShaderReflection_interfaces_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__ShaderReflection_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__ShaderReflection_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__ShaderReflection_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.ShaderReflection",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_ShaderReflection_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__ShaderReflection_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__ShaderReflection_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__ShaderReflection_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__ShaderReflection_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"The reflection and metadata fully describing a shader.\n"
		"\n"
		"The information in this structure is API agnostic.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__ShaderReflection_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__ShaderReflection_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__ShaderReflection_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_ShaderReflection,    /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__ShaderReflection_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__ShaderReflection_type};

static SwigPyGetSet VKDynamicOffset___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKDynamicOffset_descriptorByteOffset_getset = { _wrap_VKDynamicOffset_descriptorByteOffset_get, _wrap_VKDynamicOffset_descriptorByteOffset_set };
static SwigPyGetSet VKDynamicOffset_dynamicBufferByteOffset_getset = { _wrap_VKDynamicOffset_dynamicBufferByteOffset_get, _wrap_VKDynamicOffset_dynamicBufferByteOffset_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__DynamicOffset_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::DynamicOffset.__dict__", (void *) &VKDynamicOffset___dict___getset }
,
    { (char *) "descriptorByteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in bytes to the descriptor in the storage.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKDynamicOffset_descriptorByteOffset_getset }
,
    { (char *) "dynamicBufferByteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The dynamic offset to apply to the buffer in bytes.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKDynamicOffset_dynamicBufferByteOffset_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__DynamicOffset_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_VKDynamicOffset___eq__(self, other); break;
    case Py_LT : result = _wrap_VKDynamicOffset___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__DynamicOffset_methods[] = {
  { "__eq__", (PyCFunction) _wrap_VKDynamicOffset___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_VKDynamicOffset___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__DynamicOffset_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKDynamicOffset",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKDynamicOffset_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__DynamicOffset_type.as_number,         /* tp_as_number */
    &SwigPyBuiltin__VKPipe__DynamicOffset_type.as_sequence,       /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__DynamicOffset_type.as_mapping,        /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__DynamicOffset_type.as_buffer,         /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A dynamic offset applied to a single descriptor access.",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__DynamicOffset_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__DynamicOffset_methods,                 /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__DynamicOffset_getset,                  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKDynamicOffset,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__DynamicOffset_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__DynamicOffset_type};

static SwigPyGetSet VKDescriptorSet_pushDescriptor_getset = { _wrap_VKDescriptorSet_pushDescriptor_get, _wrap_VKDescriptorSet_pushDescriptor_set };
static SwigPyGetSet VKDescriptorSet_layoutResourceId_getset = { _wrap_VKDescriptorSet_layoutResourceId_get, _wrap_VKDescriptorSet_layoutResourceId_set };
static SwigPyGetSet VKDescriptorSet_descriptorSetResourceId_getset = { _wrap_VKDescriptorSet_descriptorSetResourceId_get, _wrap_VKDescriptorSet_descriptorSetResourceId_set };
static SwigPyGetSet VKDescriptorSet_descriptorBufferEmbeddedSamplers_getset = { _wrap_VKDescriptorSet_descriptorBufferEmbeddedSamplers_get, _wrap_VKDescriptorSet_descriptorBufferEmbeddedSamplers_set };
static SwigPyGetSet VKDescriptorSet___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKDescriptorSet_dynamicOffsets_getset = { _wrap_VKDescriptorSet_dynamicOffsets_get, _wrap_VKDescriptorSet_dynamicOffsets_set };
static SwigPyGetSet VKDescriptorSet_descriptorBufferByteOffset_getset = { _wrap_VKDescriptorSet_descriptorBufferByteOffset_get, _wrap_VKDescriptorSet_descriptorBufferByteOffset_set };
static SwigPyGetSet VKDescriptorSet_descriptorBufferIndex_getset = { _wrap_VKDescriptorSet_descriptorBufferIndex_get, _wrap_VKDescriptorSet_descriptorBufferIndex_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__DescriptorSet_getset[] = {
    { (char *) "pushDescriptor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Indicates if this is a virtual 'push' descriptor set.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKDescriptorSet_pushDescriptor_getset }
,
    { (char *) "layoutResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the descriptor set layout that matches this set.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKDescriptorSet_layoutResourceId_getset }
,
    { (char *) "descriptorSetResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the descriptor set object, if a real descriptor set is bound.\n"
		"\n"
		".. note::\n"
		"  If using descriptor buffers this value may be unset, see :data:`descriptorBufferIndex`.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKDescriptorSet_descriptorSetResourceId_getset }
,
    { (char *) "descriptorBufferEmbeddedSamplers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Indicates if this is a virtual descriptor set for binding embedded immutable samplers.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKDescriptorSet_descriptorBufferEmbeddedSamplers_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::DescriptorSet.__dict__", (void *) &VKDescriptorSet___dict___getset }
,
    { (char *) "dynamicOffsets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A list of dynamic offsets to be applied to specific bindings, on top of the contents\n"
		"of their descriptors.\n"
		"\n"
		".. note::\n"
		"  The returned values from :meth:`PipeState.GetConstantBuffer` already have these offsets applied.\n"
		"\n"
		":type: List[VKDynamicOffset]\n"
		"\n"
		"", (void *) &VKDescriptorSet_dynamicOffsets_getset }
,
    { (char *) "descriptorBufferByteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset from the start of the descriptor buffer at index :data:`descriptorBufferIndex` where this set's data is.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKDescriptorSet_descriptorBufferByteOffset_getset }
,
    { (char *) "descriptorBufferIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index of the descriptor buffer to be used, or ``-1`` if no descriptor buffer is used.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKDescriptorSet_descriptorBufferIndex_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__DescriptorSet_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_VKDescriptorSet___eq__(self, other); break;
    case Py_LT : result = _wrap_VKDescriptorSet___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__DescriptorSet_methods[] = {
  { "__eq__", (PyCFunction) _wrap_VKDescriptorSet___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_VKDescriptorSet___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__DescriptorSet_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKDescriptorSet",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKDescriptorSet_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__DescriptorSet_type.as_number,         /* tp_as_number */
    &SwigPyBuiltin__VKPipe__DescriptorSet_type.as_sequence,       /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__DescriptorSet_type.as_mapping,        /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__DescriptorSet_type.as_buffer,         /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The contents of a descriptor set.",      /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__DescriptorSet_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__DescriptorSet_methods,                 /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__DescriptorSet_getset,                  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKDescriptorSet,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__DescriptorSet_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__DescriptorSet_type};

static SwigPyGetSet VKDescriptorBuffer_pushDescriptor_getset = { _wrap_VKDescriptorBuffer_pushDescriptor_get, _wrap_VKDescriptorBuffer_pushDescriptor_set };
static SwigPyGetSet VKDescriptorBuffer_pushBuffer_getset = { _wrap_VKDescriptorBuffer_pushBuffer_get, _wrap_VKDescriptorBuffer_pushBuffer_set };
static SwigPyGetSet VKDescriptorBuffer_samplerBuffer_getset = { _wrap_VKDescriptorBuffer_samplerBuffer_get, _wrap_VKDescriptorBuffer_samplerBuffer_set };
static SwigPyGetSet VKDescriptorBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKDescriptorBuffer_offset_getset = { _wrap_VKDescriptorBuffer_offset_get, _wrap_VKDescriptorBuffer_offset_set };
static SwigPyGetSet VKDescriptorBuffer_buffer_getset = { _wrap_VKDescriptorBuffer_buffer_get, _wrap_VKDescriptorBuffer_buffer_set };
static SwigPyGetSet VKDescriptorBuffer_resourceBuffer_getset = { _wrap_VKDescriptorBuffer_resourceBuffer_get, _wrap_VKDescriptorBuffer_resourceBuffer_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__DescriptorBuffer_getset[] = {
    { (char *) "pushDescriptor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Indicates if this is the 'push' descriptor buffer.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKDescriptorBuffer_pushDescriptor_getset }
,
    { (char *) "pushBuffer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For push descriptors where a buffer is required, the :class:`ResourceId` of the push buffer object.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKDescriptorBuffer_pushBuffer_getset }
,
    { (char *) "samplerBuffer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Indicates if this buffer can contain samplers.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKDescriptorBuffer_samplerBuffer_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::DescriptorBuffer.__dict__", (void *) &VKDescriptorBuffer___dict___getset }
,
    { (char *) "offset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in bytes from the base of the buffer object to the start of the bound region.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKDescriptorBuffer_offset_getset }
,
    { (char *) "buffer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the buffer object being bound.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKDescriptorBuffer_buffer_getset }
,
    { (char *) "resourceBuffer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Indicates if this buffer can contain resources (buffers and images).\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKDescriptorBuffer_resourceBuffer_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__DescriptorBuffer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_VKDescriptorBuffer___eq__(self, other); break;
    case Py_LT : result = _wrap_VKDescriptorBuffer___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__DescriptorBuffer_methods[] = {
  { "__eq__", (PyCFunction) _wrap_VKDescriptorBuffer___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_VKDescriptorBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__DescriptorBuffer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKDescriptorBuffer",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKDescriptorBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__DescriptorBuffer_type.as_number,      /* tp_as_number */
    &SwigPyBuiltin__VKPipe__DescriptorBuffer_type.as_sequence,    /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__DescriptorBuffer_type.as_mapping,     /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__DescriptorBuffer_type.as_buffer,      /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "A single descriptor buffer binding.",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__DescriptorBuffer_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__DescriptorBuffer_methods,              /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__DescriptorBuffer_getset,               /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKDescriptorBuffer,  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__DescriptorBuffer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__DescriptorBuffer_type};

static SwigPyGetSet VKPipeline_pipelineResourceId_getset = { _wrap_VKPipeline_pipelineResourceId_get, _wrap_VKPipeline_pipelineResourceId_set };
static SwigPyGetSet VKPipeline_pipelineComputeLayoutResourceId_getset = { _wrap_VKPipeline_pipelineComputeLayoutResourceId_get, _wrap_VKPipeline_pipelineComputeLayoutResourceId_set };
static SwigPyGetSet VKPipeline_pipelinePreRastLayoutResourceId_getset = { _wrap_VKPipeline_pipelinePreRastLayoutResourceId_get, _wrap_VKPipeline_pipelinePreRastLayoutResourceId_set };
static SwigPyGetSet VKPipeline_pipelineFragmentLayoutResourceId_getset = { _wrap_VKPipeline_pipelineFragmentLayoutResourceId_get, _wrap_VKPipeline_pipelineFragmentLayoutResourceId_set };
static SwigPyGetSet VKPipeline_descriptorBuffers_getset = { _wrap_VKPipeline_descriptorBuffers_get, _wrap_VKPipeline_descriptorBuffers_set };
static SwigPyGetSet VKPipeline___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKPipeline_flags_getset = { _wrap_VKPipeline_flags_get, _wrap_VKPipeline_flags_set };
static SwigPyGetSet VKPipeline_descriptorSets_getset = { _wrap_VKPipeline_descriptorSets_get, _wrap_VKPipeline_descriptorSets_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__Pipeline_getset[] = {
    { (char *) "pipelineResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the pipeline object.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKPipeline_pipelineResourceId_getset }
,
    { (char *) "pipelineComputeLayoutResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the compute pipeline layout object.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKPipeline_pipelineComputeLayoutResourceId_getset }
,
    { (char *) "pipelinePreRastLayoutResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the pre-rasterization pipeline layout object.\n"
		"\n"
		"When not using pipeline libraries, this will be identical to :data:`pipelineFragmentLayoutResourceId`.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKPipeline_pipelinePreRastLayoutResourceId_getset }
,
    { (char *) "pipelineFragmentLayoutResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the fragment pipeline layout object.\n"
		"\n"
		"When not using pipeline libraries, this will be identical to :data:`pipelinePreRastLayoutResourceId`.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKPipeline_pipelineFragmentLayoutResourceId_getset }
,
    { (char *) "descriptorBuffers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound descriptor buffers.\n"
		"\n"
		":type: List[VKDescriptorBuffer]\n"
		"\n"
		"", (void *) &VKPipeline_descriptorBuffers_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::Pipeline.__dict__", (void *) &VKPipeline___dict___getset }
,
    { (char *) "flags", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The flags used to create the pipeline object.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKPipeline_flags_getset }
,
    { (char *) "descriptorSets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound descriptor sets.\n"
		"\n"
		":type: List[VKDescriptorSet]\n"
		"\n"
		"", (void *) &VKPipeline_descriptorSets_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__Pipeline_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__Pipeline_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__Pipeline_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKPipeline",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKPipeline_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__Pipeline_type.as_number,              /* tp_as_number */
    &SwigPyBuiltin__VKPipe__Pipeline_type.as_sequence,            /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__Pipeline_type.as_mapping,             /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__Pipeline_type.as_buffer,              /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the object and descriptor set bindings of a Vulkan pipeline object.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__Pipeline_richcompare,    /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__Pipeline_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__Pipeline_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKPipeline,          /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__Pipeline_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__Pipeline_type};

static SwigPyGetSet VKIndexBuffer_resourceId_getset = { _wrap_VKIndexBuffer_resourceId_get, _wrap_VKIndexBuffer_resourceId_set };
static SwigPyGetSet VKIndexBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKIndexBuffer_byteStride_getset = { _wrap_VKIndexBuffer_byteStride_get, _wrap_VKIndexBuffer_byteStride_set };
static SwigPyGetSet VKIndexBuffer_byteOffset_getset = { _wrap_VKIndexBuffer_byteOffset_get, _wrap_VKIndexBuffer_byteOffset_set };
static SwigPyGetSet VKIndexBuffer_byteSize_getset = { _wrap_VKIndexBuffer_byteSize_get, _wrap_VKIndexBuffer_byteSize_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__IndexBuffer_getset[] = {
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the index buffer.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKIndexBuffer_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::IndexBuffer.__dict__", (void *) &VKIndexBuffer___dict___getset }
,
    { (char *) "byteStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of bytes for each index in the index buffer. Typically 2 or 4 bytes but\n"
		"it can be 0 if no index buffer is bound.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKIndexBuffer_byteStride_getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset from the start of the buffer to the beginning of the index data.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKIndexBuffer_byteOffset_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte size from the start offset to the end of the index data.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKIndexBuffer_byteSize_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__IndexBuffer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__IndexBuffer_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__IndexBuffer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKIndexBuffer",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKIndexBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__IndexBuffer_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__VKPipe__IndexBuffer_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__IndexBuffer_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__IndexBuffer_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the Vulkan index buffer binding.",                 /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__IndexBuffer_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__IndexBuffer_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__IndexBuffer_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKIndexBuffer,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__IndexBuffer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__IndexBuffer_type};

static SwigPyGetSet VKInputAssembly_indexBuffer_getset = { _wrap_VKInputAssembly_indexBuffer_get, _wrap_VKInputAssembly_indexBuffer_set };
static SwigPyGetSet VKInputAssembly___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKInputAssembly_topology_getset = { _wrap_VKInputAssembly_topology_get, _wrap_VKInputAssembly_topology_set };
static SwigPyGetSet VKInputAssembly_primitiveRestartEnable_getset = { _wrap_VKInputAssembly_primitiveRestartEnable_get, _wrap_VKInputAssembly_primitiveRestartEnable_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__InputAssembly_getset[] = {
    { (char *) "indexBuffer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index buffer binding.\n"
		"\n"
		":type: VKIndexBuffer\n"
		"\n"
		"", (void *) &VKInputAssembly_indexBuffer_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::InputAssembly.__dict__", (void *) &VKInputAssembly___dict___getset }
,
    { (char *) "topology", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current primitive topology.\n"
		"\n"
		":type: Topology\n"
		"\n"
		"", (void *) &VKInputAssembly_topology_getset }
,
    { (char *) "primitiveRestartEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if primitive restart is enabled for strip primitives.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKInputAssembly_primitiveRestartEnable_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__InputAssembly_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__InputAssembly_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__InputAssembly_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKInputAssembly",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKInputAssembly_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__InputAssembly_type.as_number,         /* tp_as_number */
    &SwigPyBuiltin__VKPipe__InputAssembly_type.as_sequence,       /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__InputAssembly_type.as_mapping,        /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__InputAssembly_type.as_buffer,         /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the vulkan input assembly configuration.",         /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__InputAssembly_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__InputAssembly_methods,                 /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__InputAssembly_getset,                  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKInputAssembly,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__InputAssembly_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__InputAssembly_type};

static SwigPyGetSet VKVertexAttribute_binding_getset = { _wrap_VKVertexAttribute_binding_get, _wrap_VKVertexAttribute_binding_set };
static SwigPyGetSet VKVertexAttribute_location_getset = { _wrap_VKVertexAttribute_location_get, _wrap_VKVertexAttribute_location_set };
static SwigPyGetSet VKVertexAttribute_format_getset = { _wrap_VKVertexAttribute_format_get, _wrap_VKVertexAttribute_format_set };
static SwigPyGetSet VKVertexAttribute___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKVertexAttribute_byteOffset_getset = { _wrap_VKVertexAttribute_byteOffset_get, _wrap_VKVertexAttribute_byteOffset_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__VertexAttribute_getset[] = {
    { (char *) "binding", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex binding where data will be sourced from.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKVertexAttribute_binding_getset }
,
    { (char *) "location", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The location in the shader that is bound to this attribute.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKVertexAttribute_location_getset }
,
    { (char *) "format", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The format describing how the input element is interpreted.\n"
		"\n"
		":type: ResourceFormat\n"
		"\n"
		"", (void *) &VKVertexAttribute_format_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::VertexAttribute.__dict__", (void *) &VKVertexAttribute___dict___getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset from the start of each vertex data in the :data:`binding` to this attribute.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKVertexAttribute_byteOffset_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__VertexAttribute_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_VKVertexAttribute___eq__(self, other); break;
    case Py_LT : result = _wrap_VKVertexAttribute___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__VertexAttribute_methods[] = {
  { "__eq__", (PyCFunction) _wrap_VKVertexAttribute___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_VKVertexAttribute___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__VertexAttribute_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKVertexAttribute",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKVertexAttribute_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__VertexAttribute_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__VKPipe__VertexAttribute_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__VertexAttribute_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__VertexAttribute_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the configuration of a single vertex attribute.",  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__VertexAttribute_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__VertexAttribute_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__VertexAttribute_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKVertexAttribute,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__VertexAttribute_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__VertexAttribute_type};

static SwigPyGetSet VKVertexBinding_vertexBufferBinding_getset = { _wrap_VKVertexBinding_vertexBufferBinding_get, _wrap_VKVertexBinding_vertexBufferBinding_set };
static SwigPyGetSet VKVertexBinding_instanceDivisor_getset = { _wrap_VKVertexBinding_instanceDivisor_get, _wrap_VKVertexBinding_instanceDivisor_set };
static SwigPyGetSet VKVertexBinding___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKVertexBinding_perInstance_getset = { _wrap_VKVertexBinding_perInstance_get, _wrap_VKVertexBinding_perInstance_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__VertexBinding_getset[] = {
    { (char *) "vertexBufferBinding", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex binding where data will be sourced from.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKVertexBinding_vertexBufferBinding_getset }
,
    { (char *) "instanceDivisor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The instance rate divisor.\n"
		"\n"
		"If this is ``0`` then every vertex gets the same value.\n"
		"\n"
		"If it's ``1`` then one element is read for each instance, and for ``N`` greater than ``1`` then\n"
		"``N`` instances read the same element before advancing.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKVertexBinding_instanceDivisor_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::VertexBinding.__dict__", (void *) &VKVertexBinding___dict___getset }
,
    { (char *) "perInstance", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the vertex data is instance-rate.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKVertexBinding_perInstance_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__VertexBinding_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_VKVertexBinding___eq__(self, other); break;
    case Py_LT : result = _wrap_VKVertexBinding___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__VertexBinding_methods[] = {
  { "__eq__", (PyCFunction) _wrap_VKVertexBinding___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_VKVertexBinding___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__VertexBinding_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKVertexBinding",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKVertexBinding_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__VertexBinding_type.as_number,         /* tp_as_number */
    &SwigPyBuiltin__VKPipe__VertexBinding_type.as_sequence,       /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__VertexBinding_type.as_mapping,        /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__VertexBinding_type.as_buffer,         /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a vertex binding.",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__VertexBinding_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__VertexBinding_methods,                 /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__VertexBinding_getset,                  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKVertexBinding,     /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__VertexBinding_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__VertexBinding_type};

static SwigPyGetSet VKVertexBuffer_resourceId_getset = { _wrap_VKVertexBuffer_resourceId_get, _wrap_VKVertexBuffer_resourceId_set };
static SwigPyGetSet VKVertexBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKVertexBuffer_byteStride_getset = { _wrap_VKVertexBuffer_byteStride_get, _wrap_VKVertexBuffer_byteStride_set };
static SwigPyGetSet VKVertexBuffer_byteOffset_getset = { _wrap_VKVertexBuffer_byteOffset_get, _wrap_VKVertexBuffer_byteOffset_set };
static SwigPyGetSet VKVertexBuffer_byteSize_getset = { _wrap_VKVertexBuffer_byteSize_get, _wrap_VKVertexBuffer_byteSize_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__VertexBuffer_getset[] = {
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the buffer bound to this slot.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKVertexBuffer_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::VertexBuffer.__dict__", (void *) &VKVertexBuffer___dict___getset }
,
    { (char *) "byteStride", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte stride between the start of one set of vertex data and the next.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKVertexBuffer_byteStride_getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset from the start of the buffer to the beginning of the vertex data.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKVertexBuffer_byteOffset_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size of the vertex buffer.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKVertexBuffer_byteSize_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__VertexBuffer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_VKVertexBuffer___eq__(self, other); break;
    case Py_LT : result = _wrap_VKVertexBuffer___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__VertexBuffer_methods[] = {
  { "__eq__", (PyCFunction) _wrap_VKVertexBuffer___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_VKVertexBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__VertexBuffer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKVertexBuffer",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKVertexBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__VertexBuffer_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__VKPipe__VertexBuffer_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__VertexBuffer_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__VertexBuffer_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a single Vulkan vertex buffer binding.",           /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__VertexBuffer_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__VertexBuffer_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__VertexBuffer_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKVertexBuffer,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__VertexBuffer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__VertexBuffer_type};

static SwigPyGetSet VKVertexInput_attributes_getset = { _wrap_VKVertexInput_attributes_get, _wrap_VKVertexInput_attributes_set };
static SwigPyGetSet VKVertexInput_vertexBuffers_getset = { _wrap_VKVertexInput_vertexBuffers_get, _wrap_VKVertexInput_vertexBuffers_set };
static SwigPyGetSet VKVertexInput___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKVertexInput_bindings_getset = { _wrap_VKVertexInput_bindings_get, _wrap_VKVertexInput_bindings_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__VertexInput_getset[] = {
    { (char *) "attributes", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex attributes.\n"
		"\n"
		":type: List[VKVertexAttribute]\n"
		"\n"
		"", (void *) &VKVertexInput_attributes_getset }
,
    { (char *) "vertexBuffers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex buffers.\n"
		"\n"
		":type: List[VKVertexBuffer]\n"
		"\n"
		"", (void *) &VKVertexInput_vertexBuffers_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::VertexInput.__dict__", (void *) &VKVertexInput___dict___getset }
,
    { (char *) "bindings", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex bindings.\n"
		"\n"
		":type: List[VKVertexBinding]\n"
		"\n"
		"", (void *) &VKVertexInput_bindings_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__VertexInput_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__VertexInput_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__VertexInput_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKVertexInput",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKVertexInput_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__VertexInput_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__VKPipe__VertexInput_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__VertexInput_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__VertexInput_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the fixed-function vertex input fetch setup.",     /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__VertexInput_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__VertexInput_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__VertexInput_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKVertexInput,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__VertexInput_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__VertexInput_type};

static SwigPyGetSet VKShader_reflection_getset = { _wrap_VKShader_reflection_get, _wrap_VKShader_reflection_set };
static SwigPyGetSet VKShader_shaderObject_getset = { _wrap_VKShader_shaderObject_get, _wrap_VKShader_shaderObject_set };
static SwigPyGetSet VKShader_requiredSubgroupSize_getset = { _wrap_VKShader_requiredSubgroupSize_get, _wrap_VKShader_requiredSubgroupSize_set };
static SwigPyGetSet VKShader_specializationData_getset = { _wrap_VKShader_specializationData_get, _wrap_VKShader_specializationData_set };
static SwigPyGetSet VKShader_resourceId_getset = { _wrap_VKShader_resourceId_get, _wrap_VKShader_resourceId_set };
static SwigPyGetSet VKShader_stage_getset = { _wrap_VKShader_stage_get, _wrap_VKShader_stage_set };
static SwigPyGetSet VKShader_entryPoint_getset = { _wrap_VKShader_entryPoint_get, _wrap_VKShader_entryPoint_set };
static SwigPyGetSet VKShader___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKShader_pushConstantRangeByteOffset_getset = { _wrap_VKShader_pushConstantRangeByteOffset_get, _wrap_VKShader_pushConstantRangeByteOffset_set };
static SwigPyGetSet VKShader_pushConstantRangeByteSize_getset = { _wrap_VKShader_pushConstantRangeByteSize_get, _wrap_VKShader_pushConstantRangeByteSize_set };
static SwigPyGetSet VKShader_specializationIds_getset = { _wrap_VKShader_specializationIds_get, _wrap_VKShader_specializationIds_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__Shader_getset[] = {
    { (char *) "reflection", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The reflection data for this shader.\n"
		"\n"
		":type: ShaderReflection\n"
		"\n"
		"", (void *) &VKShader_reflection_getset }
,
    { (char *) "shaderObject", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Whether the shader is a shader object or shader module.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKShader_shaderObject_getset }
,
    { (char *) "requiredSubgroupSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The required subgroup size specified for this shader at pipeline creation time.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKShader_requiredSubgroupSize_getset }
,
    { (char *) "specializationData", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The provided specialization constant data. Shader constants store the byte offset into\n"
		"this buffer as their byteOffset. This data includes the applied specialization constants over the\n"
		"top of the default values, so it is safe to read any constant from here and get the correct current\n"
		"value.\n"
		"\n"
		":type: bytes\n"
		"\n"
		"", (void *) &VKShader_specializationData_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the shader module object.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKShader_resourceId_getset }
,
    { (char *) "stage", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A :class:`ShaderStage` identifying which stage this shader is bound to.\n"
		"\n"
		":type: ShaderStage\n"
		"\n"
		"", (void *) &VKShader_stage_getset }
,
    { (char *) "entryPoint", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of the entry point in the shader module that is used.\n"
		"\n"
		":type: str\n"
		"", (void *) &VKShader_entryPoint_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::Shader.__dict__", (void *) &VKShader___dict___getset }
,
    { (char *) "pushConstantRangeByteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset into the push constant data that is visible to this shader.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKShader_pushConstantRangeByteOffset_getset }
,
    { (char *) "pushConstantRangeByteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of bytes in the push constant data that is visible to this shader.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKShader_pushConstantRangeByteSize_getset }
,
    { (char *) "specializationIds", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The specialization constant ID for each entry in the specialization constant block of\n"
		"reflection info. This corresponds to the constantID in VkSpecializationMapEntry, while the offset\n"
		"and size into specializationData can be obtained from the reflection info.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &VKShader_specializationIds_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__Shader_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__Shader_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__Shader_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKShader",                     /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKShader_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__Shader_type.as_number,                /* tp_as_number */
    &SwigPyBuiltin__VKPipe__Shader_type.as_sequence,              /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__Shader_type.as_mapping,               /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__Shader_type.as_buffer,                /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a Vulkan shader stage.",       /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__Shader_richcompare,      /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__Shader_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__Shader_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKShader,            /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__Shader_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__Shader_type};

static SwigPyGetSet VKTessellation___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKTessellation_domainOriginUpperLeft_getset = { _wrap_VKTessellation_domainOriginUpperLeft_get, _wrap_VKTessellation_domainOriginUpperLeft_set };
static SwigPyGetSet VKTessellation_numControlPoints_getset = { _wrap_VKTessellation_numControlPoints_get, _wrap_VKTessellation_numControlPoints_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__Tessellation_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::Tessellation.__dict__", (void *) &VKTessellation___dict___getset }
,
    { (char *) "domainOriginUpperLeft", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the tessellation domain origin is upper-left, ``False`` if lower-left.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKTessellation_domainOriginUpperLeft_getset }
,
    { (char *) "numControlPoints", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of control points in each input patch.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKTessellation_numControlPoints_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__Tessellation_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__Tessellation_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__Tessellation_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKTessellation",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKTessellation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__Tessellation_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__VKPipe__Tessellation_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__Tessellation_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__Tessellation_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the state of the fixed-function tessellator.",     /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__Tessellation_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__Tessellation_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__Tessellation_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKTessellation,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__Tessellation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__Tessellation_type};

static SwigPyGetSet VKXFBBuffer_active_getset = { _wrap_VKXFBBuffer_active_get, _wrap_VKXFBBuffer_active_set };
static SwigPyGetSet VKXFBBuffer_bufferResourceId_getset = { _wrap_VKXFBBuffer_bufferResourceId_get, _wrap_VKXFBBuffer_bufferResourceId_set };
static SwigPyGetSet VKXFBBuffer_counterBufferResourceId_getset = { _wrap_VKXFBBuffer_counterBufferResourceId_get, _wrap_VKXFBBuffer_counterBufferResourceId_set };
static SwigPyGetSet VKXFBBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKXFBBuffer_byteOffset_getset = { _wrap_VKXFBBuffer_byteOffset_get, _wrap_VKXFBBuffer_byteOffset_set };
static SwigPyGetSet VKXFBBuffer_byteSize_getset = { _wrap_VKXFBBuffer_byteSize_get, _wrap_VKXFBBuffer_byteSize_set };
static SwigPyGetSet VKXFBBuffer_counterBufferOffset_getset = { _wrap_VKXFBBuffer_counterBufferOffset_get, _wrap_VKXFBBuffer_counterBufferOffset_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__XFBBuffer_getset[] = {
    { (char *) "active", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A flag indicating if this buffer is active or not.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKXFBBuffer_active_getset }
,
    { (char *) "bufferResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the bound data buffer.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKXFBBuffer_bufferResourceId_getset }
,
    { (char *) "counterBufferResourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the buffer storing the counter value (if set).\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKXFBBuffer_counterBufferResourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::XFBBuffer.__dict__", (void *) &VKXFBBuffer___dict___getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in bytes to the start of the data in the :data:`bufferResourceId`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKXFBBuffer_byteOffset_getset }
,
    { (char *) "byteSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size in bytes of the data buffer.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKXFBBuffer_byteSize_getset }
,
    { (char *) "counterBufferOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The offset in bytes to the counter in the :data:`counterBufferResourceId`.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKXFBBuffer_counterBufferOffset_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__XFBBuffer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_VKXFBBuffer___eq__(self, other); break;
    case Py_LT : result = _wrap_VKXFBBuffer___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__XFBBuffer_methods[] = {
  { "__eq__", (PyCFunction) _wrap_VKXFBBuffer___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_VKXFBBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__XFBBuffer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKXFBBuffer",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKXFBBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__XFBBuffer_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__VKPipe__XFBBuffer_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__XFBBuffer_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__XFBBuffer_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a single transform feedback binding.",             /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__XFBBuffer_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__XFBBuffer_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__XFBBuffer_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKXFBBuffer,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__XFBBuffer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__XFBBuffer_type};

static SwigPyGetSet VKTransformFeedback_buffers_getset = { _wrap_VKTransformFeedback_buffers_get, _wrap_VKTransformFeedback_buffers_set };
static SwigPyGetSet VKTransformFeedback___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKTransformFeedback_rasterizedStream_getset = { _wrap_VKTransformFeedback_rasterizedStream_get, _wrap_VKTransformFeedback_rasterizedStream_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__TransformFeedback_getset[] = {
    { (char *) "buffers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound transform feedback buffers.\n"
		"\n"
		":type: List[VKXFBBuffer]\n"
		"\n"
		"", (void *) &VKTransformFeedback_buffers_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::TransformFeedback.__dict__", (void *) &VKTransformFeedback___dict___getset }
,
    { (char *) "rasterizedStream", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Which stream-out stream is being used for rasterization.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKTransformFeedback_rasterizedStream_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__TransformFeedback_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__TransformFeedback_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__TransformFeedback_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKTransformFeedback",          /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKTransformFeedback_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__TransformFeedback_type.as_number,     /* tp_as_number */
    &SwigPyBuiltin__VKPipe__TransformFeedback_type.as_sequence,   /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__TransformFeedback_type.as_mapping,    /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__TransformFeedback_type.as_buffer,     /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the state of the fixed-function transform feedback.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__TransformFeedback_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__TransformFeedback_methods,             /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__TransformFeedback_getset,              /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKTransformFeedback, /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__TransformFeedback_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__TransformFeedback_type};

static SwigPyGetSet VKRenderArea_x_getset = { _wrap_VKRenderArea_x_get, _wrap_VKRenderArea_x_set };
static SwigPyGetSet VKRenderArea_y_getset = { _wrap_VKRenderArea_y_get, _wrap_VKRenderArea_y_set };
static SwigPyGetSet VKRenderArea_height_getset = { _wrap_VKRenderArea_height_get, _wrap_VKRenderArea_height_set };
static SwigPyGetSet VKRenderArea___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKRenderArea_width_getset = { _wrap_VKRenderArea_width_get, _wrap_VKRenderArea_width_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__RenderArea_getset[] = {
    { (char *) "x", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The X co-ordinate of the render area.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRenderArea_x_getset }
,
    { (char *) "y", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The Y co-ordinate of the render area.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRenderArea_y_getset }
,
    { (char *) "height", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The height of the render area.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRenderArea_height_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::RenderArea.__dict__", (void *) &VKRenderArea___dict___getset }
,
    { (char *) "width", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The width of the render area.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRenderArea_width_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__RenderArea_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_VKRenderArea___eq__(self, other); break;
    case Py_LT : result = _wrap_VKRenderArea___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__RenderArea_methods[] = {
  { "__eq__", (PyCFunction) _wrap_VKRenderArea___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_VKRenderArea___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__RenderArea_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKRenderArea",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKRenderArea_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__RenderArea_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__VKPipe__RenderArea_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__RenderArea_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__RenderArea_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a render area in the current framebuffer.",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__RenderArea_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__RenderArea_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__RenderArea_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKRenderArea,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__RenderArea_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__RenderArea_type};

static SwigPyGetSet VKViewportScissor___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKViewportScissor_vp_getset = { _wrap_VKViewportScissor_vp_get, _wrap_VKViewportScissor_vp_set };
static SwigPyGetSet VKViewportScissor_scissor_getset = { _wrap_VKViewportScissor_scissor_get, _wrap_VKViewportScissor_scissor_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__ViewportScissor_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::ViewportScissor.__dict__", (void *) &VKViewportScissor___dict___getset }
,
    { (char *) "vp", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The viewport.\n"
		"\n"
		":type: Viewport\n"
		"\n"
		"", (void *) &VKViewportScissor_vp_getset }
,
    { (char *) "scissor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The scissor.\n"
		"\n"
		":type: Scissor\n"
		"\n"
		"", (void *) &VKViewportScissor_scissor_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__ViewportScissor_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_VKViewportScissor___eq__(self, other); break;
    case Py_LT : result = _wrap_VKViewportScissor___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__ViewportScissor_methods[] = {
  { "__eq__", (PyCFunction) _wrap_VKViewportScissor___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_VKViewportScissor___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__ViewportScissor_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKViewportScissor",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKViewportScissor_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__ViewportScissor_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__VKPipe__ViewportScissor_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__ViewportScissor_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__ViewportScissor_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a combined viewport and scissor region.",          /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__ViewportScissor_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__ViewportScissor_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__ViewportScissor_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKViewportScissor,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__ViewportScissor_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__ViewportScissor_type};

static SwigPyGetSet VKViewState_discardRectanglesExclusive_getset = { _wrap_VKViewState_discardRectanglesExclusive_get, _wrap_VKViewState_discardRectanglesExclusive_set };
static SwigPyGetSet VKViewState_discardRectangles_getset = { _wrap_VKViewState_discardRectangles_get, _wrap_VKViewState_discardRectangles_set };
static SwigPyGetSet VKViewState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKViewState_viewportScissors_getset = { _wrap_VKViewState_viewportScissors_get, _wrap_VKViewState_viewportScissors_set };
static SwigPyGetSet VKViewState_depthNegativeOneToOne_getset = { _wrap_VKViewState_depthNegativeOneToOne_get, _wrap_VKViewState_depthNegativeOneToOne_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__ViewState_getset[] = {
    { (char *) "discardRectanglesExclusive", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if a fragment in any one of the discard rectangles fails the discard test,\n"
		"and a fragment in none of them passes.\n"
		"\n"
		"``False`` if a fragment in any one of the discard rectangles passes the discard test,\n"
		"and a fragment in none of them is discarded.\n"
		"\n"
		".. note::\n"
		"  A ``True`` value and an empty list of :data:`discardRectangles` means the test is effectively\n"
		"  disabled, since with no rectangles no fragment can be inside one.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKViewState_discardRectanglesExclusive_getset }
,
    { (char *) "discardRectangles", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The discard rectangles, if enabled.\n"
		"\n"
		":type: List[VKRenderArea]\n"
		"\n"
		"", (void *) &VKViewState_discardRectangles_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::ViewState.__dict__", (void *) &VKViewState___dict___getset }
,
    { (char *) "viewportScissors", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The bound viewports and scissors.\n"
		"\n"
		":type: List[VKViewportScissor]\n"
		"\n"
		"", (void *) &VKViewState_viewportScissors_getset }
,
    { (char *) "depthNegativeOneToOne", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Whether depth clip range is set to [-1, 1] through VK_EXT_depth_clip_control.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKViewState_depthNegativeOneToOne_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__ViewState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__ViewState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__ViewState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKViewState",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKViewState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__ViewState_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__VKPipe__ViewState_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__ViewState_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__ViewState_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the view state in the pipeline.",                  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__ViewState_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__ViewState_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__ViewState_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKViewState,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__ViewState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__ViewState_type};

static SwigPyGetSet VKRasterizer_depthBias_getset = { _wrap_VKRasterizer_depthBias_get, _wrap_VKRasterizer_depthBias_set };
static SwigPyGetSet VKRasterizer_slopeScaledDepthBias_getset = { _wrap_VKRasterizer_slopeScaledDepthBias_get, _wrap_VKRasterizer_slopeScaledDepthBias_set };
static SwigPyGetSet VKRasterizer_depthBiasClamp_getset = { _wrap_VKRasterizer_depthBiasClamp_get, _wrap_VKRasterizer_depthBiasClamp_set };
static SwigPyGetSet VKRasterizer_fillMode_getset = { _wrap_VKRasterizer_fillMode_get, _wrap_VKRasterizer_fillMode_set };
static SwigPyGetSet VKRasterizer_cullMode_getset = { _wrap_VKRasterizer_cullMode_get, _wrap_VKRasterizer_cullMode_set };
static SwigPyGetSet VKRasterizer_lineStippleFactor_getset = { _wrap_VKRasterizer_lineStippleFactor_get, _wrap_VKRasterizer_lineStippleFactor_set };
static SwigPyGetSet VKRasterizer_pipelineShadingRate_getset = { _wrap_VKRasterizer_pipelineShadingRate_get, _wrap_VKRasterizer_pipelineShadingRate_set };
static SwigPyGetSet VKRasterizer_lineStipplePattern_getset = { _wrap_VKRasterizer_lineStipplePattern_get, _wrap_VKRasterizer_lineStipplePattern_set };
static SwigPyGetSet VKRasterizer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKRasterizer_provokingVertexFirst_getset = { _wrap_VKRasterizer_provokingVertexFirst_get, _wrap_VKRasterizer_provokingVertexFirst_set };
static SwigPyGetSet VKRasterizer_shadingRateCombiners_getset = { _wrap_VKRasterizer_shadingRateCombiners_get, _wrap_VKRasterizer_shadingRateCombiners_set };
static SwigPyGetSet VKRasterizer_frontCCW_getset = { _wrap_VKRasterizer_frontCCW_get, _wrap_VKRasterizer_frontCCW_set };
static SwigPyGetSet VKRasterizer_extraPrimitiveOverestimationSize_getset = { _wrap_VKRasterizer_extraPrimitiveOverestimationSize_get, _wrap_VKRasterizer_extraPrimitiveOverestimationSize_set };
static SwigPyGetSet VKRasterizer_depthBiasEnable_getset = { _wrap_VKRasterizer_depthBiasEnable_get, _wrap_VKRasterizer_depthBiasEnable_set };
static SwigPyGetSet VKRasterizer_lineRasterMode_getset = { _wrap_VKRasterizer_lineRasterMode_get, _wrap_VKRasterizer_lineRasterMode_set };
static SwigPyGetSet VKRasterizer_depthClampEnable_getset = { _wrap_VKRasterizer_depthClampEnable_get, _wrap_VKRasterizer_depthClampEnable_set };
static SwigPyGetSet VKRasterizer_depthClipEnable_getset = { _wrap_VKRasterizer_depthClipEnable_get, _wrap_VKRasterizer_depthClipEnable_set };
static SwigPyGetSet VKRasterizer_rasterizerDiscardEnable_getset = { _wrap_VKRasterizer_rasterizerDiscardEnable_get, _wrap_VKRasterizer_rasterizerDiscardEnable_set };
static SwigPyGetSet VKRasterizer_lineWidth_getset = { _wrap_VKRasterizer_lineWidth_get, _wrap_VKRasterizer_lineWidth_set };
static SwigPyGetSet VKRasterizer_conservativeRasterization_getset = { _wrap_VKRasterizer_conservativeRasterization_get, _wrap_VKRasterizer_conservativeRasterization_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__Rasterizer_getset[] = {
    { (char *) "depthBias", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed depth bias value to apply to z-values.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &VKRasterizer_depthBias_getset }
,
    { (char *) "slopeScaledDepthBias", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The slope-scaled depth bias value to apply to z-values.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &VKRasterizer_slopeScaledDepthBias_getset }
,
    { (char *) "depthBiasClamp", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The clamp value for calculated depth bias from :data:`depthBias` and\n"
		":data:`slopeScaledDepthBias`\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &VKRasterizer_depthBiasClamp_getset }
,
    { (char *) "fillMode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The polygon :class:`FillMode`.\n"
		"\n"
		":type: FillMode\n"
		"\n"
		"", (void *) &VKRasterizer_fillMode_getset }
,
    { (char *) "cullMode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The polygon :class:`CullMode`.\n"
		"\n"
		":type: CullMode\n"
		"\n"
		"", (void *) &VKRasterizer_cullMode_getset }
,
    { (char *) "lineStippleFactor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The line stipple factor, or 0 if line stipple is disabled.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRasterizer_lineStippleFactor_getset }
,
    { (char *) "pipelineShadingRate", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current pipeline fragment shading rate. This will always be 1x1 when a fragment\n"
		"shading rate has not been specified.\n"
		"\n"
		":type: Tuple[int,int]\n"
		"\n"
		"", (void *) &VKRasterizer_pipelineShadingRate_getset }
,
    { (char *) "lineStipplePattern", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The line stipple bit-pattern.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRasterizer_lineStipplePattern_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::Rasterizer.__dict__", (void *) &VKRasterizer___dict___getset }
,
    { (char *) "provokingVertexFirst", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Whether the provoking vertex is the first one (default behaviour).\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKRasterizer_provokingVertexFirst_getset }
,
    { (char *) "shadingRateCombiners", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fragment shading rate combiners.\n"
		"\n"
		"The combiners are applied as follows, according to the Vulkan spec:\n"
		"\n"
		"  ``intermediateRate = combiner[0] ( pipelineShadingRate,  shaderExportedShadingRate )``\n"
		"  ``finalRate        = combiner[1] ( intermediateRate,     imageBasedShadingRate     )``\n"
		"\n"
		"Where the first input is from :data:`pipelineShadingRate` and the second is the exported shading\n"
		"rate from the last pre-rasterization shader stage, which defaults to 1x1 if not exported.\n"
		"\n"
		"The intermediate result is then used as the first input to the second combiner, together with the\n"
		"shading rate sampled from the fragment shading rate attachment.\n"
		"\n"
		":type: Tuple[ShadingRateCombiner,ShadingRateCombiner]\n"
		"\n"
		"", (void *) &VKRasterizer_shadingRateCombiners_getset }
,
    { (char *) "frontCCW", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if counter-clockwise polygons are front-facing.\n"
		"``False`` if clockwise polygons are front-facing.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKRasterizer_frontCCW_getset }
,
    { (char *) "extraPrimitiveOverestimationSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The extra size in pixels to increase primitives by during conservative rasterization,\n"
		"in the x and y directions in screen space.\n"
		"\n"
		"See :data:`conservativeRasterizationMode`\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &VKRasterizer_extraPrimitiveOverestimationSize_getset }
,
    { (char *) "depthBiasEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Whether depth biasing is enabled.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKRasterizer_depthBiasEnable_getset }
,
    { (char *) "lineRasterMode", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The line rasterization mode.\n"
		"\n"
		":type: LineRaster\n"
		"\n"
		"", (void *) &VKRasterizer_lineRasterMode_getset }
,
    { (char *) "depthClampEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if pixels outside of the near and far depth planes should be clamped and\n"
		"to ``0.0`` to ``1.0``.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKRasterizer_depthClampEnable_getset }
,
    { (char *) "depthClipEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if pixels outside of the near and far depth planes should be clipped.\n"
		"\n"
		".. note::\n"
		"  In Vulkan 1.0 this value was implicitly set to the opposite of :data:`depthClampEnable`, but with\n"
		"  later extensions & versions it can be set independently.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKRasterizer_depthClipEnable_getset }
,
    { (char *) "rasterizerDiscardEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if primitives should be discarded during rasterization.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKRasterizer_rasterizerDiscardEnable_getset }
,
    { (char *) "lineWidth", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fixed line width in pixels.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &VKRasterizer_lineWidth_getset }
,
    { (char *) "conservativeRasterization", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The active conservative rasterization mode.\n"
		"\n"
		":type: ConservativeRaster\n"
		"\n"
		"", (void *) &VKRasterizer_conservativeRasterization_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__Rasterizer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__Rasterizer_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__Rasterizer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKRasterizer",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKRasterizer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__Rasterizer_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__VKPipe__Rasterizer_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__Rasterizer_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__Rasterizer_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the rasterizer state in the pipeline.",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__Rasterizer_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__Rasterizer_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__Rasterizer_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKRasterizer,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__Rasterizer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__Rasterizer_type};

static SwigPyGetSet VKSampleLocations___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKSampleLocations_gridHeight_getset = { _wrap_VKSampleLocations_gridHeight_get, _wrap_VKSampleLocations_gridHeight_set };
static SwigPyGetSet VKSampleLocations_customLocations_getset = { _wrap_VKSampleLocations_customLocations_get, _wrap_VKSampleLocations_customLocations_set };
static SwigPyGetSet VKSampleLocations_gridWidth_getset = { _wrap_VKSampleLocations_gridWidth_get, _wrap_VKSampleLocations_gridWidth_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__SampleLocations_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::SampleLocations.__dict__", (void *) &VKSampleLocations___dict___getset }
,
    { (char *) "gridHeight", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The height in pixels of the region configured.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKSampleLocations_gridHeight_getset }
,
    { (char *) "customLocations", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The custom sample locations. Only x and y are valid, z and w are set to 0.0.\n"
		"\n"
		"If the list is empty then the standard sample pattern is in use.\n"
		"\n"
		":type: List[FloatVector]\n"
		"\n"
		"", (void *) &VKSampleLocations_customLocations_getset }
,
    { (char *) "gridWidth", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The width in pixels of the region configured.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKSampleLocations_gridWidth_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__SampleLocations_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__SampleLocations_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__SampleLocations_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKSampleLocations",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKSampleLocations_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__SampleLocations_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__VKPipe__SampleLocations_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__SampleLocations_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__SampleLocations_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes state of custom sample locations in the pipeline.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__SampleLocations_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__SampleLocations_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__SampleLocations_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKSampleLocations,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__SampleLocations_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__SampleLocations_type};

static SwigPyGetSet VKMultiSample_minSampleShading_getset = { _wrap_VKMultiSample_minSampleShading_get, _wrap_VKMultiSample_minSampleShading_set };
static SwigPyGetSet VKMultiSample_rasterSamples_getset = { _wrap_VKMultiSample_rasterSamples_get, _wrap_VKMultiSample_rasterSamples_set };
static SwigPyGetSet VKMultiSample___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKMultiSample_sampleShadingEnable_getset = { _wrap_VKMultiSample_sampleShadingEnable_get, _wrap_VKMultiSample_sampleShadingEnable_set };
static SwigPyGetSet VKMultiSample_sampleMask_getset = { _wrap_VKMultiSample_sampleMask_get, _wrap_VKMultiSample_sampleMask_set };
static SwigPyGetSet VKMultiSample_sampleLocations_getset = { _wrap_VKMultiSample_sampleLocations_get, _wrap_VKMultiSample_sampleLocations_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__MultiSample_getset[] = {
    { (char *) "minSampleShading", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The minimum sample shading rate.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &VKMultiSample_minSampleShading_getset }
,
    { (char *) "rasterSamples", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"How many samples to use when rasterizing.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKMultiSample_rasterSamples_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::MultiSample.__dict__", (void *) &VKMultiSample___dict___getset }
,
    { (char *) "sampleShadingEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if rendering should happen at sample-rate frequency.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKMultiSample_sampleShadingEnable_getset }
,
    { (char *) "sampleMask", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"A mask that generated samples should be masked with using bitwise ``AND``.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKMultiSample_sampleMask_getset }
,
    { (char *) "sampleLocations", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The custom sample locations configuration.\n"
		"\n"
		":type: VKSampleLocations\n"
		"\n"
		"", (void *) &VKMultiSample_sampleLocations_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__MultiSample_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__MultiSample_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__MultiSample_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKMultiSample",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKMultiSample_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__MultiSample_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__VKPipe__MultiSample_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__MultiSample_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__MultiSample_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the multisampling state in the pipeline.",         /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__MultiSample_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__MultiSample_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__MultiSample_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKMultiSample,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__MultiSample_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__MultiSample_type};

static SwigPyGetSet VKColorBlendState_blends_getset = { _wrap_VKColorBlendState_blends_get, _wrap_VKColorBlendState_blends_set };
static SwigPyGetSet VKColorBlendState_blendFactor_getset = { _wrap_VKColorBlendState_blendFactor_get, _wrap_VKColorBlendState_blendFactor_set };
static SwigPyGetSet VKColorBlendState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKColorBlendState_alphaToCoverageEnable_getset = { _wrap_VKColorBlendState_alphaToCoverageEnable_get, _wrap_VKColorBlendState_alphaToCoverageEnable_set };
static SwigPyGetSet VKColorBlendState_alphaToOneEnable_getset = { _wrap_VKColorBlendState_alphaToOneEnable_get, _wrap_VKColorBlendState_alphaToOneEnable_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__ColorBlendState_getset[] = {
    { (char *) "blends", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The blend operations for each target.\n"
		"\n"
		":type: List[ColorBlend]\n"
		"\n"
		"", (void *) &VKColorBlendState_blends_getset }
,
    { (char *) "blendFactor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The constant blend factor to use in blend equations.\n"
		"\n"
		":type: Tuple[float,float,float,float]\n"
		"\n"
		"", (void *) &VKColorBlendState_blendFactor_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::ColorBlendState.__dict__", (void *) &VKColorBlendState___dict___getset }
,
    { (char *) "alphaToCoverageEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if alpha-to-coverage should be used when blending to an MSAA target.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKColorBlendState_alphaToCoverageEnable_getset }
,
    { (char *) "alphaToOneEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if alpha-to-one should be used when blending to an MSAA target.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKColorBlendState_alphaToOneEnable_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__ColorBlendState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__ColorBlendState_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__ColorBlendState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKColorBlendState",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKColorBlendState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__ColorBlendState_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__VKPipe__ColorBlendState_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__ColorBlendState_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__ColorBlendState_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the pipeline blending state.", /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__ColorBlendState_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__ColorBlendState_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__ColorBlendState_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKColorBlendState,   /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__ColorBlendState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__ColorBlendState_type};

static SwigPyGetSet VKDepthStencil_frontFace_getset = { _wrap_VKDepthStencil_frontFace_get, _wrap_VKDepthStencil_frontFace_set };
static SwigPyGetSet VKDepthStencil_backFace_getset = { _wrap_VKDepthStencil_backFace_get, _wrap_VKDepthStencil_backFace_set };
static SwigPyGetSet VKDepthStencil_depthFunction_getset = { _wrap_VKDepthStencil_depthFunction_get, _wrap_VKDepthStencil_depthFunction_set };
static SwigPyGetSet VKDepthStencil___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKDepthStencil_depthWriteEnable_getset = { _wrap_VKDepthStencil_depthWriteEnable_get, _wrap_VKDepthStencil_depthWriteEnable_set };
static SwigPyGetSet VKDepthStencil_depthBoundsEnable_getset = { _wrap_VKDepthStencil_depthBoundsEnable_get, _wrap_VKDepthStencil_depthBoundsEnable_set };
static SwigPyGetSet VKDepthStencil_minDepthBounds_getset = { _wrap_VKDepthStencil_minDepthBounds_get, _wrap_VKDepthStencil_minDepthBounds_set };
static SwigPyGetSet VKDepthStencil_maxDepthBounds_getset = { _wrap_VKDepthStencil_maxDepthBounds_get, _wrap_VKDepthStencil_maxDepthBounds_set };
static SwigPyGetSet VKDepthStencil_depthTestEnable_getset = { _wrap_VKDepthStencil_depthTestEnable_get, _wrap_VKDepthStencil_depthTestEnable_set };
static SwigPyGetSet VKDepthStencil_stencilTestEnable_getset = { _wrap_VKDepthStencil_stencilTestEnable_get, _wrap_VKDepthStencil_stencilTestEnable_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__DepthStencil_getset[] = {
    { (char *) "frontFace", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stencil state for front-facing polygons.\n"
		"\n"
		":type: StencilFace\n"
		"\n"
		"", (void *) &VKDepthStencil_frontFace_getset }
,
    { (char *) "backFace", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The stencil state for back-facing polygons.\n"
		"\n"
		":type: StencilFace\n"
		"\n"
		"", (void *) &VKDepthStencil_backFace_getset }
,
    { (char *) "depthFunction", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`CompareFunction` to use for testing depth values.\n"
		"\n"
		":type: CompareFunction\n"
		"\n"
		"", (void *) &VKDepthStencil_depthFunction_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::DepthStencil.__dict__", (void *) &VKDepthStencil___dict___getset }
,
    { (char *) "depthWriteEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth values should be written to the depth target.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKDepthStencil_depthWriteEnable_getset }
,
    { (char *) "depthBoundsEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth bounds tests should be applied.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKDepthStencil_depthBoundsEnable_getset }
,
    { (char *) "minDepthBounds", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The near plane bounding value.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &VKDepthStencil_minDepthBounds_getset }
,
    { (char *) "maxDepthBounds", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The far plane bounding value.\n"
		"\n"
		":type: float\n"
		"\n"
		"", (void *) &VKDepthStencil_maxDepthBounds_getset }
,
    { (char *) "depthTestEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if depth testing should be performed.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKDepthStencil_depthTestEnable_getset }
,
    { (char *) "stencilTestEnable", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if stencil operations should be performed.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKDepthStencil_stencilTestEnable_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__DepthStencil_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__DepthStencil_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__DepthStencil_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKDepthStencil",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKDepthStencil_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__DepthStencil_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__VKPipe__DepthStencil_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__DepthStencil_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__DepthStencil_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the pipeline depth-stencil state.",                /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__DepthStencil_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__DepthStencil_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__DepthStencil_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKDepthStencil,      /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__DepthStencil_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__DepthStencil_type};

static SwigPyGetSet VKRenderPass_inputAttachments_getset = { _wrap_VKRenderPass_inputAttachments_get, _wrap_VKRenderPass_inputAttachments_set };
static SwigPyGetSet VKRenderPass_colorAttachments_getset = { _wrap_VKRenderPass_colorAttachments_get, _wrap_VKRenderPass_colorAttachments_set };
static SwigPyGetSet VKRenderPass_resolveAttachments_getset = { _wrap_VKRenderPass_resolveAttachments_get, _wrap_VKRenderPass_resolveAttachments_set };
static SwigPyGetSet VKRenderPass_multiviews_getset = { _wrap_VKRenderPass_multiviews_get, _wrap_VKRenderPass_multiviews_set };
static SwigPyGetSet VKRenderPass_subpass_getset = { _wrap_VKRenderPass_subpass_get, _wrap_VKRenderPass_subpass_set };
static SwigPyGetSet VKRenderPass_resourceId_getset = { _wrap_VKRenderPass_resourceId_get, _wrap_VKRenderPass_resourceId_set };
static SwigPyGetSet VKRenderPass_shadingRateTexelSize_getset = { _wrap_VKRenderPass_shadingRateTexelSize_get, _wrap_VKRenderPass_shadingRateTexelSize_set };
static SwigPyGetSet VKRenderPass___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKRenderPass_fragmentDensityOffsets_getset = { _wrap_VKRenderPass_fragmentDensityOffsets_get, _wrap_VKRenderPass_fragmentDensityOffsets_set };
static SwigPyGetSet VKRenderPass_colorAttachmentInputIndices_getset = { _wrap_VKRenderPass_colorAttachmentInputIndices_get, _wrap_VKRenderPass_colorAttachmentInputIndices_set };
static SwigPyGetSet VKRenderPass_depthstencilAttachment_getset = { _wrap_VKRenderPass_depthstencilAttachment_get, _wrap_VKRenderPass_depthstencilAttachment_set };
static SwigPyGetSet VKRenderPass_depthstencilResolveAttachment_getset = { _wrap_VKRenderPass_depthstencilResolveAttachment_get, _wrap_VKRenderPass_depthstencilResolveAttachment_set };
static SwigPyGetSet VKRenderPass_fragmentDensityAttachment_getset = { _wrap_VKRenderPass_fragmentDensityAttachment_get, _wrap_VKRenderPass_fragmentDensityAttachment_set };
static SwigPyGetSet VKRenderPass_shadingRateAttachment_getset = { _wrap_VKRenderPass_shadingRateAttachment_get, _wrap_VKRenderPass_shadingRateAttachment_set };
static SwigPyGetSet VKRenderPass_tileOnlyMSAASampleCount_getset = { _wrap_VKRenderPass_tileOnlyMSAASampleCount_get, _wrap_VKRenderPass_tileOnlyMSAASampleCount_set };
static SwigPyGetSet VKRenderPass_dynamic_getset = { _wrap_VKRenderPass_dynamic_get, _wrap_VKRenderPass_dynamic_set };
static SwigPyGetSet VKRenderPass_suspended_getset = { _wrap_VKRenderPass_suspended_get, _wrap_VKRenderPass_suspended_set };
static SwigPyGetSet VKRenderPass_depthInputAttachmentIndex_getset = { _wrap_VKRenderPass_depthInputAttachmentIndex_get, _wrap_VKRenderPass_depthInputAttachmentIndex_set };
static SwigPyGetSet VKRenderPass_stencilInputAttachmentIndex_getset = { _wrap_VKRenderPass_stencilInputAttachmentIndex_get, _wrap_VKRenderPass_stencilInputAttachmentIndex_set };
static SwigPyGetSet VKRenderPass_colorAttachmentLocations_getset = { _wrap_VKRenderPass_colorAttachmentLocations_get, _wrap_VKRenderPass_colorAttachmentLocations_set };
static SwigPyGetSet VKRenderPass_isDepthInputAttachmentIndexImplicit_getset = { _wrap_VKRenderPass_isDepthInputAttachmentIndexImplicit_get, _wrap_VKRenderPass_isDepthInputAttachmentIndexImplicit_set };
static SwigPyGetSet VKRenderPass_isStencilInputAttachmentIndexImplicit_getset = { _wrap_VKRenderPass_isStencilInputAttachmentIndexImplicit_get, _wrap_VKRenderPass_isStencilInputAttachmentIndexImplicit_set };
static SwigPyGetSet VKRenderPass_feedbackLoop_getset = { _wrap_VKRenderPass_feedbackLoop_get, _wrap_VKRenderPass_feedbackLoop_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__RenderPass_getset[] = {
    { (char *) "inputAttachments", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The input attachments for the current subpass, as indices into the framebuffer\n"
		"attachments.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &VKRenderPass_inputAttachments_getset }
,
    { (char *) "colorAttachments", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The color attachments for the current subpass, as indices into the framebuffer\n"
		"attachments.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &VKRenderPass_colorAttachments_getset }
,
    { (char *) "resolveAttachments", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The resolve attachments for the current subpass, as indices into the framebuffer\n"
		"attachments.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &VKRenderPass_resolveAttachments_getset }
,
    { (char *) "multiviews", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If multiview is enabled, contains a list of view indices to be broadcast to during\n"
		"rendering.\n"
		"\n"
		"If the list is empty, multiview is disabled and rendering is as normal.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &VKRenderPass_multiviews_getset }
,
    { (char *) "subpass", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The index of the current active subpass.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRenderPass_subpass_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the render pass.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKRenderPass_resourceId_getset }
,
    { (char *) "shadingRateTexelSize", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The size of the framebuffer region represented by each texel in\n"
		":data:`shadingRateAttachment`.\n"
		"\n"
		"For example if this is (2,2) then every texel in the attachment gives the shading rate of a 2x2\n"
		"block in the framebuffer so the shading rate attachment is half the size of the other attachments in\n"
		"each dimension.\n"
		"\n"
		"If no attachment is set in :data:`shadingRateAttachment` this will be (1,1).\n"
		"\n"
		":type: Tuple[int,int]\n"
		"\n"
		"", (void *) &VKRenderPass_shadingRateTexelSize_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::RenderPass.__dict__", (void *) &VKRenderPass___dict___getset }
,
    { (char *) "fragmentDensityOffsets", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If VK_QCOM_fragment_density_map_offset is enabled, contains a list of offsets applied \n"
		"to the fragment density map during rendering.\n"
		"\n"
		"If the list is empty, fdm_offset is disabled and rendering is as normal.\n"
		"\n"
		":type: List[Offset]\n"
		"\n"
		"", (void *) &VKRenderPass_fragmentDensityOffsets_getset }
,
    { (char *) "colorAttachmentInputIndices", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The color index->input index mapping set up by dynamic rendering local read.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &VKRenderPass_colorAttachmentInputIndices_getset }
,
    { (char *) "depthstencilAttachment", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An index into the framebuffer attachments for the depth-stencil attachment.\n"
		"\n"
		"If there is no depth-stencil attachment, this index is ``-1``.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRenderPass_depthstencilAttachment_getset }
,
    { (char *) "depthstencilResolveAttachment", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An index into the framebuffer attachments for the depth-stencil resolve attachment.\n"
		"\n"
		"If there is no depth-stencil resolve attachment, this index is ``-1``.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRenderPass_depthstencilResolveAttachment_getset }
,
    { (char *) "fragmentDensityAttachment", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An index into the framebuffer attachments for the fragment density attachment.\n"
		"\n"
		"If there is no fragment density attachment, this index is ``-1``.\n"
		"\n"
		".. note::\n"
		"  Only one at most of :data:`fragmentDensityAttachment` and :data:`shadingRateAttachment` will be\n"
		"  set.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRenderPass_fragmentDensityAttachment_getset }
,
    { (char *) "shadingRateAttachment", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"An index into the framebuffer attachments for the fragment shading rate attachment.\n"
		"\n"
		"If there is no fragment shading rate attachment, this index is ``-1``.\n"
		"\n"
		".. note::\n"
		"  Only one at most of :data:`fragmentDensityAttachment` and :data:`shadingRateAttachment` will be\n"
		"  set.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRenderPass_shadingRateAttachment_getset }
,
    { (char *) "tileOnlyMSAASampleCount", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If VK_EXT_multisampled_render_to_single_sampled is enabled, contains the number of\n"
		"samples used to render this subpass.\n"
		"\n"
		"If the subpass is not internally multisampled, tileOnlyMSAASampleCount is set to 0.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRenderPass_tileOnlyMSAASampleCount_getset }
,
    { (char *) "dynamic", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Whether or not dynamic rendering is in use (no render pass or framebuffer objects).\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKRenderPass_dynamic_getset }
,
    { (char *) "suspended", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Whether or not dynamic rendering is currently suspended.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKRenderPass_suspended_getset }
,
    { (char *) "depthInputAttachmentIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Depth input attachment index if explicit (dynamic rendering).\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRenderPass_depthInputAttachmentIndex_getset }
,
    { (char *) "stencilInputAttachmentIndex", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Stencil input attachment index if explicit (dynamic rendering).\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKRenderPass_stencilInputAttachmentIndex_getset }
,
    { (char *) "colorAttachmentLocations", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The color index->location mapping set up by dynamic rendering local read.\n"
		"\n"
		":type: List[int]\n"
		"\n"
		"", (void *) &VKRenderPass_colorAttachmentLocations_getset }
,
    { (char *) "isDepthInputAttachmentIndexImplicit", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Whether or not depth input attachment index is implicit (dynamic rendering).\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKRenderPass_isDepthInputAttachmentIndexImplicit_getset }
,
    { (char *) "isStencilInputAttachmentIndexImplicit", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Whether or not stencil  input attachment index is implicit (dynamic rendering).\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKRenderPass_isStencilInputAttachmentIndexImplicit_getset }
,
    { (char *) "feedbackLoop", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"Whether or not there is a potential feedback loop.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKRenderPass_feedbackLoop_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__RenderPass_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__RenderPass_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__RenderPass_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKRenderPass",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKRenderPass_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__RenderPass_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__VKPipe__RenderPass_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__RenderPass_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__RenderPass_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"Describes the setup of a renderpass and subpasses.\n"
		"\n"
		".. data:: AttachmentUnused\n"
		"\n"
		"  Alias for VK_ATTACHMENT_UNUSED, for use by the UI to know when a value in colorAttachmentLocations\n"
		"  or colorAttachmentInputIndices is mapped to VK_ATTACHMENT_UNUSED.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__RenderPass_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__RenderPass_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__RenderPass_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKRenderPass,        /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__RenderPass_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__RenderPass_type};

static SwigPyGetSet VKFramebuffer_attachments_getset = { _wrap_VKFramebuffer_attachments_get, _wrap_VKFramebuffer_attachments_set };
static SwigPyGetSet VKFramebuffer_height_getset = { _wrap_VKFramebuffer_height_get, _wrap_VKFramebuffer_height_set };
static SwigPyGetSet VKFramebuffer_resourceId_getset = { _wrap_VKFramebuffer_resourceId_get, _wrap_VKFramebuffer_resourceId_set };
static SwigPyGetSet VKFramebuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKFramebuffer_width_getset = { _wrap_VKFramebuffer_width_get, _wrap_VKFramebuffer_width_set };
static SwigPyGetSet VKFramebuffer_layers_getset = { _wrap_VKFramebuffer_layers_get, _wrap_VKFramebuffer_layers_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__Framebuffer_getset[] = {
    { (char *) "attachments", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The attachments of this framebuffer.\n"
		"\n"
		":type: List[Descriptor]\n"
		"\n"
		"", (void *) &VKFramebuffer_attachments_getset }
,
    { (char *) "height", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The height of this framebuffer in pixels.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKFramebuffer_height_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the framebuffer object.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKFramebuffer_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::Framebuffer.__dict__", (void *) &VKFramebuffer___dict___getset }
,
    { (char *) "width", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The width of this framebuffer in pixels.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKFramebuffer_width_getset }
,
    { (char *) "layers", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of layers in this framebuffer.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKFramebuffer_layers_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__Framebuffer_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__Framebuffer_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__Framebuffer_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKFramebuffer",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKFramebuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__Framebuffer_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__VKPipe__Framebuffer_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__Framebuffer_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__Framebuffer_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes a framebuffer object and its attachments.",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__Framebuffer_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__Framebuffer_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__Framebuffer_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKFramebuffer,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__Framebuffer_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__Framebuffer_type};

static SwigPyGetSet VKCurrentPass_renderpass_getset = { _wrap_VKCurrentPass_renderpass_get, _wrap_VKCurrentPass_renderpass_set };
static SwigPyGetSet VKCurrentPass_framebuffer_getset = { _wrap_VKCurrentPass_framebuffer_get, _wrap_VKCurrentPass_framebuffer_set };
static SwigPyGetSet VKCurrentPass___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKCurrentPass_renderArea_getset = { _wrap_VKCurrentPass_renderArea_get, _wrap_VKCurrentPass_renderArea_set };
static SwigPyGetSet VKCurrentPass_colorFeedbackAllowed_getset = { _wrap_VKCurrentPass_colorFeedbackAllowed_get, _wrap_VKCurrentPass_colorFeedbackAllowed_set };
static SwigPyGetSet VKCurrentPass_depthFeedbackAllowed_getset = { _wrap_VKCurrentPass_depthFeedbackAllowed_get, _wrap_VKCurrentPass_depthFeedbackAllowed_set };
static SwigPyGetSet VKCurrentPass_stencilFeedbackAllowed_getset = { _wrap_VKCurrentPass_stencilFeedbackAllowed_get, _wrap_VKCurrentPass_stencilFeedbackAllowed_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__CurrentPass_getset[] = {
    { (char *) "renderpass", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The renderpass and subpass that is currently active.\n"
		"\n"
		":type: VKRenderPass\n"
		"\n"
		"", (void *) &VKCurrentPass_renderpass_getset }
,
    { (char *) "framebuffer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The framebuffer that is currently being used.\n"
		"\n"
		":type: VKFramebuffer\n"
		"\n"
		"", (void *) &VKCurrentPass_framebuffer_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::CurrentPass.__dict__", (void *) &VKCurrentPass___dict___getset }
,
    { (char *) "renderArea", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The render area that is currently being rendered to.\n"
		"\n"
		":type: VKRenderArea\n"
		"\n"
		"", (void *) &VKCurrentPass_renderArea_getset }
,
    { (char *) "colorFeedbackAllowed", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If feedback loops are allowed on color attachments\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKCurrentPass_colorFeedbackAllowed_getset }
,
    { (char *) "depthFeedbackAllowed", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If feedback loops are allowed on depth attachments\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKCurrentPass_depthFeedbackAllowed_getset }
,
    { (char *) "stencilFeedbackAllowed", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"If feedback loops are allowed on stencil attachments\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKCurrentPass_stencilFeedbackAllowed_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__CurrentPass_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__CurrentPass_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__CurrentPass_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKCurrentPass",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKCurrentPass_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__CurrentPass_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__VKPipe__CurrentPass_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__CurrentPass_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__CurrentPass_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Describes the current pass instance at the current time.",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__CurrentPass_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__CurrentPass_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__CurrentPass_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKCurrentPass,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__CurrentPass_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__CurrentPass_type};

static SwigPyGetSet VKImageLayout_name_getset = { _wrap_VKImageLayout_name_get, _wrap_VKImageLayout_name_set };
static SwigPyGetSet VKImageLayout___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKImageLayout_numMip_getset = { _wrap_VKImageLayout_numMip_get, _wrap_VKImageLayout_numMip_set };
static SwigPyGetSet VKImageLayout_numLayer_getset = { _wrap_VKImageLayout_numLayer_get, _wrap_VKImageLayout_numLayer_set };
static SwigPyGetSet VKImageLayout_baseLayer_getset = { _wrap_VKImageLayout_baseLayer_get, _wrap_VKImageLayout_baseLayer_set };
static SwigPyGetSet VKImageLayout_baseMip_getset = { _wrap_VKImageLayout_baseMip_get, _wrap_VKImageLayout_baseMip_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__ImageLayout_getset[] = {
    { (char *) "name", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The name of the current image state.\n"
		"\n"
		":type: str\n"
		"\n"
		"", (void *) &VKImageLayout_name_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::ImageLayout.__dict__", (void *) &VKImageLayout___dict___getset }
,
    { (char *) "numMip", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The number of mip levels in the range.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKImageLayout_numMip_getset }
,
    { (char *) "numLayer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For 3D textures and texture arrays, the number of array slices in the range.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKImageLayout_numLayer_getset }
,
    { (char *) "baseLayer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"For 3D textures and texture arrays, the first slice used in the range.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKImageLayout_baseLayer_getset }
,
    { (char *) "baseMip", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The first mip level used in the range.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKImageLayout_baseMip_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__ImageLayout_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_VKImageLayout___eq__(self, other); break;
    case Py_LT : result = _wrap_VKImageLayout___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__ImageLayout_methods[] = {
  { "__eq__", (PyCFunction) _wrap_VKImageLayout___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_VKImageLayout___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__ImageLayout_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKImageLayout",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKImageLayout_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__ImageLayout_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__VKPipe__ImageLayout_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__ImageLayout_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__ImageLayout_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the layout of a range of subresources in an image.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__ImageLayout_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__ImageLayout_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__ImageLayout_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKImageLayout,       /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__ImageLayout_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__ImageLayout_type};

static SwigPyGetSet VKImageData_layouts_getset = { _wrap_VKImageData_layouts_get, _wrap_VKImageData_layouts_set };
static SwigPyGetSet VKImageData_resourceId_getset = { _wrap_VKImageData_resourceId_get, _wrap_VKImageData_resourceId_set };
static SwigPyGetSet VKImageData___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__ImageData_getset[] = {
    { (char *) "layouts", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The subresource regions in this resource.\n"
		"\n"
		":type: List[VKImageLayout]\n"
		"\n"
		"", (void *) &VKImageData_layouts_getset }
,
    { (char *) "resourceId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the image.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKImageData_resourceId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::ImageData.__dict__", (void *) &VKImageData___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__ImageData_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_VKImageData___eq__(self, other); break;
    case Py_LT : result = _wrap_VKImageData___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__ImageData_methods[] = {
  { "__eq__", (PyCFunction) _wrap_VKImageData___eq__, METH_O, (char *) "__eq__(o)" },
  { "__lt__", (PyCFunction) _wrap_VKImageData___lt__, METH_O, (char *) "__lt__(o)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__ImageData_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKImageData",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKImageData_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__ImageData_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__VKPipe__ImageData_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__ImageData_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__ImageData_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the current layout of all subresources in the image.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__ImageData_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__ImageData_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__ImageData_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKImageData,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__ImageData_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__ImageData_type};

static SwigPyGetSet VKConditionalRendering_isInverted_getset = { _wrap_VKConditionalRendering_isInverted_get, _wrap_VKConditionalRendering_isInverted_set };
static SwigPyGetSet VKConditionalRendering_bufferId_getset = { _wrap_VKConditionalRendering_bufferId_get, _wrap_VKConditionalRendering_bufferId_set };
static SwigPyGetSet VKConditionalRendering___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKConditionalRendering_byteOffset_getset = { _wrap_VKConditionalRendering_byteOffset_get, _wrap_VKConditionalRendering_byteOffset_set };
static SwigPyGetSet VKConditionalRendering_isPassing_getset = { _wrap_VKConditionalRendering_isPassing_get, _wrap_VKConditionalRendering_isPassing_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__ConditionalRendering_getset[] = {
    { (char *) "isInverted", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if predicate result is inverted.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKConditionalRendering_isInverted_getset }
,
    { (char *) "bufferId", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The :class:`ResourceId` of the buffer containing the predicate for conditional rendering.\n"
		"\n"
		":type: ResourceId\n"
		"\n"
		"", (void *) &VKConditionalRendering_bufferId_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::ConditionalRendering.__dict__", (void *) &VKConditionalRendering___dict___getset }
,
    { (char *) "byteOffset", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The byte offset into buffer where the predicate is located.\n"
		"\n"
		":type: int\n"
		"\n"
		"", (void *) &VKConditionalRendering_byteOffset_getset }
,
    { (char *) "isPassing", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"``True`` if the current predicate would render.\n"
		"\n"
		":type: bool\n"
		"\n"
		"", (void *) &VKConditionalRendering_isPassing_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__ConditionalRendering_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__ConditionalRendering_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__ConditionalRendering_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKConditionalRendering",       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKConditionalRendering_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__ConditionalRendering_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__VKPipe__ConditionalRendering_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__ConditionalRendering_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__ConditionalRendering_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "Contains the current conditional rendering state.",          /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__ConditionalRendering_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__ConditionalRendering_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__ConditionalRendering_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_VKConditionalRendering,                  /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__ConditionalRendering_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__ConditionalRendering_type};

static SwigPyGetSet VKState_pushconsts_getset = { _wrap_VKState_pushconsts_get, _wrap_VKState_pushconsts_set };
static SwigPyGetSet VKState_tessellation_getset = { _wrap_VKState_tessellation_get, _wrap_VKState_tessellation_set };
static SwigPyGetSet VKState_transformFeedback_getset = { _wrap_VKState_transformFeedback_get, _wrap_VKState_transformFeedback_set };
static SwigPyGetSet VKState_colorBlend_getset = { _wrap_VKState_colorBlend_get, _wrap_VKState_colorBlend_set };
static SwigPyGetSet VKState_graphics_getset = { _wrap_VKState_graphics_get, _wrap_VKState_graphics_set };
static SwigPyGetSet VKState_vertexInput_getset = { _wrap_VKState_vertexInput_get, _wrap_VKState_vertexInput_set };
static SwigPyGetSet VKState_currentPass_getset = { _wrap_VKState_currentPass_get, _wrap_VKState_currentPass_set };
static SwigPyGetSet VKState___dict___getset = { SwigPyObject_get___dict__, 0 };
static SwigPyGetSet VKState_compute_getset = { _wrap_VKState_compute_get, _wrap_VKState_compute_set };
static SwigPyGetSet VKState_inputAssembly_getset = { _wrap_VKState_inputAssembly_get, _wrap_VKState_inputAssembly_set };
static SwigPyGetSet VKState_conditionalRendering_getset = { _wrap_VKState_conditionalRendering_get, _wrap_VKState_conditionalRendering_set };
static SwigPyGetSet VKState_geometryShader_getset = { _wrap_VKState_geometryShader_get, _wrap_VKState_geometryShader_set };
static SwigPyGetSet VKState_computeShader_getset = { _wrap_VKState_computeShader_get, _wrap_VKState_computeShader_set };
static SwigPyGetSet VKState_taskShader_getset = { _wrap_VKState_taskShader_get, _wrap_VKState_taskShader_set };
static SwigPyGetSet VKState_viewportScissor_getset = { _wrap_VKState_viewportScissor_get, _wrap_VKState_viewportScissor_set };
static SwigPyGetSet VKState_rasterizer_getset = { _wrap_VKState_rasterizer_get, _wrap_VKState_rasterizer_set };
static SwigPyGetSet VKState_vertexShader_getset = { _wrap_VKState_vertexShader_get, _wrap_VKState_vertexShader_set };
static SwigPyGetSet VKState_tessControlShader_getset = { _wrap_VKState_tessControlShader_get, _wrap_VKState_tessControlShader_set };
static SwigPyGetSet VKState_tessEvalShader_getset = { _wrap_VKState_tessEvalShader_get, _wrap_VKState_tessEvalShader_set };
static SwigPyGetSet VKState_fragmentShader_getset = { _wrap_VKState_fragmentShader_get, _wrap_VKState_fragmentShader_set };
static SwigPyGetSet VKState_meshShader_getset = { _wrap_VKState_meshShader_get, _wrap_VKState_meshShader_set };
static SwigPyGetSet VKState_multisample_getset = { _wrap_VKState_multisample_get, _wrap_VKState_multisample_set };
static SwigPyGetSet VKState_images_getset = { _wrap_VKState_images_get, _wrap_VKState_images_set };
static SwigPyGetSet VKState_depthStencil_getset = { _wrap_VKState_depthStencil_get, _wrap_VKState_depthStencil_set };
static SwigPyGetSet VKState_shaderMessages_getset = { _wrap_VKState_shaderMessages_get, _wrap_VKState_shaderMessages_set };
SWIGINTERN PyGetSetDef SwigPyBuiltin__VKPipe__State_getset[] = {
    { (char *) "pushconsts", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The raw push constant data.\n"
		"\n"
		":type: bytes\n"
		"\n"
		"", (void *) &VKState_pushconsts_getset }
,
    { (char *) "tessellation", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The tessellation stage.\n"
		"\n"
		":type: VKTessellation\n"
		"\n"
		"", (void *) &VKState_tessellation_getset }
,
    { (char *) "transformFeedback", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The transform feedback stage.\n"
		"\n"
		":type: VKTransformFeedback\n"
		"\n"
		"", (void *) &VKState_transformFeedback_getset }
,
    { (char *) "colorBlend", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The color blending configuration.\n"
		"\n"
		":type: VKColorBlendState\n"
		"\n"
		"", (void *) &VKState_colorBlend_getset }
,
    { (char *) "graphics", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The currently bound graphics pipeline, if any.\n"
		"\n"
		":type: VKPipeline\n"
		"\n"
		"", (void *) &VKState_graphics_getset }
,
    { (char *) "vertexInput", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex input stage.\n"
		"\n"
		":type: VKVertexInput\n"
		"\n"
		"", (void *) &VKState_vertexInput_getset }
,
    { (char *) "currentPass", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current renderpass, subpass and framebuffer.\n"
		"\n"
		":type: VKCurrentPass\n"
		"\n"
		"", (void *) &VKState_currentPass_getset }
,
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"VKPipe::State.__dict__", (void *) &VKState___dict___getset }
,
    { (char *) "compute", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The currently bound compute pipeline, if any.\n"
		"\n"
		":type: VKPipeline\n"
		"\n"
		"", (void *) &VKState_compute_getset }
,
    { (char *) "inputAssembly", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The input assembly stage.\n"
		"\n"
		":type: VKInputAssembly\n"
		"\n"
		"", (void *) &VKState_inputAssembly_getset }
,
    { (char *) "conditionalRendering", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The current conditional rendering state.\n"
		"\n"
		":type: VKConditionalRendering\n"
		"\n"
		"", (void *) &VKState_conditionalRendering_getset }
,
    { (char *) "geometryShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The geometry shader stage.\n"
		"\n"
		":type: VKShader\n"
		"\n"
		"", (void *) &VKState_geometryShader_getset }
,
    { (char *) "computeShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The compute shader stage.\n"
		"\n"
		":type: VKShader\n"
		"\n"
		"", (void *) &VKState_computeShader_getset }
,
    { (char *) "taskShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The task shader stage.\n"
		"\n"
		":type: VKShader\n"
		"\n"
		"", (void *) &VKState_taskShader_getset }
,
    { (char *) "viewportScissor", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The viewport setup.\n"
		"\n"
		":type: VKViewState\n"
		"\n"
		"", (void *) &VKState_viewportScissor_getset }
,
    { (char *) "rasterizer", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The rasterization configuration.\n"
		"\n"
		":type: VKRasterizer\n"
		"\n"
		"", (void *) &VKState_rasterizer_getset }
,
    { (char *) "vertexShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The vertex shader stage.\n"
		"\n"
		":type: VKShader\n"
		"\n"
		"", (void *) &VKState_vertexShader_getset }
,
    { (char *) "tessControlShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The tessellation control shader stage.\n"
		"\n"
		":type: VKShader\n"
		"\n"
		"", (void *) &VKState_tessControlShader_getset }
,
    { (char *) "tessEvalShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The tessellation evaluation shader stage.\n"
		"\n"
		":type: VKShader\n"
		"\n"
		"", (void *) &VKState_tessEvalShader_getset }
,
    { (char *) "fragmentShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The fragment shader stage.\n"
		"\n"
		":type: VKShader\n"
		"\n"
		"", (void *) &VKState_fragmentShader_getset }
,
    { (char *) "meshShader", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The mesh shader stage.\n"
		"\n"
		":type: VKShader\n"
		"\n"
		"", (void *) &VKState_meshShader_getset }
,
    { (char *) "multisample", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The multisampling configuration.\n"
		"\n"
		":type: VKMultiSample\n"
		"\n"
		"", (void *) &VKState_multisample_getset }
,
    { (char *) "images", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The resource states for the currently live resources.\n"
		"\n"
		":type: List[VKImageData]\n"
		"\n"
		"", (void *) &VKState_images_getset }
,
    { (char *) "depthStencil", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The depth-stencil state.\n"
		"\n"
		":type: VKDepthStencil\n"
		"\n"
		"", (void *) &VKState_depthStencil_getset }
,
    { (char *) "shaderMessages", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) SwigPyBuiltin_FunpackSetterClosure, (char *)"\n"
		"The shader messages retrieved for this action.\n"
		"\n"
		":type: List[ShaderMessage]\n"
		"\n"
		"", (void *) &VKState_shaderMessages_getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__VKPipe__State_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__VKPipe__State_methods[] = {
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__VKPipe__State_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.VKState",                      /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_VKState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__VKPipe__State_type.as_number,                 /* tp_as_number */
    &SwigPyBuiltin__VKPipe__State_type.as_sequence,               /* tp_as_sequence */
    &SwigPyBuiltin__VKPipe__State_type.as_mapping,                /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__VKPipe__State_type.as_buffer,                 /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "The full current Vulkan pipeline state.",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__VKPipe__State_richcompare,       /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__VKPipe__State_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__VKPipe__State_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__VKPipe__State_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__VKPipe__State_type};

static SwigPyGetSet PipeState___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__PipeState_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"PipeState.__dict__", (void *) &PipeState___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__PipeState_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__PipeState_methods[] = {
  { "IsCaptureLoaded", (PyCFunction) _wrap_PipeState_IsCaptureLoaded, METH_NOARGS, (char *) "\n"
		"IsCaptureLoaded()\n"
		"\n"
		"Determines whether or not a capture is currently loaded.\n"
		"\n"
		":return: A boolean indicating if a capture is currently loaded.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "IsCaptureD3D11", (PyCFunction) _wrap_PipeState_IsCaptureD3D11, METH_NOARGS, (char *) "\n"
		"IsCaptureD3D11()\n"
		"\n"
		"Determines whether or not a D3D11 capture is currently loaded.\n"
		"\n"
		":return: A boolean indicating if a D3D11 capture is currently loaded.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "IsCaptureD3D12", (PyCFunction) _wrap_PipeState_IsCaptureD3D12, METH_NOARGS, (char *) "\n"
		"IsCaptureD3D12()\n"
		"\n"
		"Determines whether or not a D3D12 capture is currently loaded.\n"
		"\n"
		":return: A boolean indicating if a D3D12 capture is currently loaded.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "IsCaptureGL", (PyCFunction) _wrap_PipeState_IsCaptureGL, METH_NOARGS, (char *) "\n"
		"IsCaptureGL()\n"
		"\n"
		"Determines whether or not an OpenGL capture is currently loaded.\n"
		"\n"
		":return: A boolean indicating if an OpenGL capture is currently loaded.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "IsCaptureVK", (PyCFunction) _wrap_PipeState_IsCaptureVK, METH_NOARGS, (char *) "\n"
		"IsCaptureVK()\n"
		"\n"
		"Determines whether or not a Vulkan capture is currently loaded.\n"
		"\n"
		":return: A boolean indicating if a Vulkan capture is currently loaded.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "IsTessellationEnabled", (PyCFunction) _wrap_PipeState_IsTessellationEnabled, METH_NOARGS, (char *) "\n"
		"IsTessellationEnabled()\n"
		"\n"
		"Determines whether or not tessellation is currently enabled.\n"
		"\n"
		":return: A boolean indicating if tessellation is currently enabled.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "MultiviewBroadcastCount", (PyCFunction) _wrap_PipeState_MultiviewBroadcastCount, METH_NOARGS, (char *) "\n"
		"MultiviewBroadcastCount()\n"
		"\n"
		"\n"
		":return: The number of views being broadcast to simultaneously during rendering.\n"
		":rtype: int\n"
		"\n"
		"" },
  { "SupportsResourceArrays", (PyCFunction) _wrap_PipeState_SupportsResourceArrays, METH_NOARGS, (char *) "\n"
		"SupportsResourceArrays()\n"
		"\n"
		"Determines whether or not the current capture supports binding arrays of resources.\n"
		"\n"
		":return: A boolean indicating if binding arrays of resources is supported.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "SupportsBarriers", (PyCFunction) _wrap_PipeState_SupportsBarriers, METH_NOARGS, (char *) "\n"
		"SupportsBarriers()\n"
		"\n"
		"Determines whether or not the current capture uses explicit barriers.\n"
		"\n"
		":return: A boolean indicating if explicit barriers are used.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "HasAlignedPostVSData", (PyCFunction) _wrap_PipeState_HasAlignedPostVSData, METH_O, (char *) "\n"
		"HasAlignedPostVSData(stage)\n"
		"\n"
		"Determines whether or not the PostVS data is aligned in the typical fashion (ie.\n"
		"vectors not crossing ``float4`` boundaries). APIs that use stream-out or transform feedback have\n"
		"tightly packed data, but APIs that rewrite shaders to dump data might have these alignment\n"
		"requirements.\n"
		"\n"
		":param MeshDataStage stage: The mesh data stage for the output data.\n"
		":return: A boolean indicating if post-VS data is aligned.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "GetRasterizedStream", (PyCFunction) _wrap_PipeState_GetRasterizedStream, METH_NOARGS, (char *) "\n"
		"GetRasterizedStream()\n"
		"\n"
		"Retrieves the rasterized stream, if multiple streams are being generated in the GS.\n"
		"\n"
		":return: The rasterized stream, or -1 of no stream is being rasterized.\n"
		":rtype: int\n"
		"\n"
		"" },
  { "GetResourceLayout", (PyCFunction) _wrap_PipeState_GetResourceLayout, METH_O, (char *) "\n"
		"GetResourceLayout(id)\n"
		"\n"
		"For APIs that have explicit barriers, retrieves the current layout of a resource.\n"
		"\n"
		":param ResourceId id: The ID of the resource to query for\n"
		":return: The name of the current layout of the first subresource in the resource.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "Abbrev", (PyCFunction) _wrap_PipeState_Abbrev, METH_O, (char *) "\n"
		"Abbrev(stage)\n"
		"\n"
		"Retrieves a suitable two or three letter abbreviation of the given shader stage.\n"
		"\n"
		":param ShaderStage stage: The shader stage to abbreviate.\n"
		":return: The abbreviation of the stage.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "OutputAbbrev", (PyCFunction) _wrap_PipeState_OutputAbbrev, METH_NOARGS, (char *) "\n"
		"OutputAbbrev()\n"
		"\n"
		"Retrieves a suitable two or three letter abbreviation of the output stage. Typically\n"
		"'OM' or 'FBO'.\n"
		"\n"
		":return: The abbreviation of the output stage.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "GetViewport", (PyCFunction) _wrap_PipeState_GetViewport, METH_O, (char *) "\n"
		"GetViewport(index)\n"
		"\n"
		"Retrieves the viewport for a given index.\n"
		"\n"
		":param int index: The index to retrieve.\n"
		":return: The viewport for the given index.\n"
		":rtype: Viewport\n"
		"\n"
		"" },
  { "GetScissor", (PyCFunction) _wrap_PipeState_GetScissor, METH_O, (char *) "\n"
		"GetScissor(index)\n"
		"\n"
		"Retrieves the scissor region for a given index.\n"
		"\n"
		":param int index: The index to retrieve.\n"
		":return: The scissor region for the given index.\n"
		":rtype: Scissor\n"
		"\n"
		"" },
  { "GetShaderReflection", (PyCFunction) _wrap_PipeState_GetShaderReflection, METH_O, (char *) "\n"
		"GetShaderReflection(stage)\n"
		"\n"
		"Retrieves the shader reflection information for a shader stage.\n"
		"\n"
		"This returns ``None`` if no shader is bound.\n"
		"\n"
		":param ShaderStage stage: The shader stage to fetch.\n"
		":return: The reflection data for the given shader.\n"
		":rtype: ShaderReflection\n"
		"\n"
		"" },
  { "GetComputePipelineObject", (PyCFunction) _wrap_PipeState_GetComputePipelineObject, METH_NOARGS, (char *) "\n"
		"GetComputePipelineObject()\n"
		"\n"
		"Retrieves the the compute pipeline state object, if applicable.\n"
		"\n"
		":return: The object ID for the given pipeline object.\n"
		":rtype: ResourceId\n"
		"\n"
		"" },
  { "GetGraphicsPipelineObject", (PyCFunction) _wrap_PipeState_GetGraphicsPipelineObject, METH_NOARGS, (char *) "\n"
		"GetGraphicsPipelineObject()\n"
		"\n"
		"Retrieves the the graphics pipeline state object, if applicable.\n"
		"\n"
		":return: The object ID for the given pipeline object.\n"
		":rtype: ResourceId\n"
		"\n"
		"" },
  { "GetShaderEntryPoint", (PyCFunction) _wrap_PipeState_GetShaderEntryPoint, METH_O, (char *) "\n"
		"GetShaderEntryPoint(stage)\n"
		"\n"
		"Retrieves the name of the entry point function for a shader stage.\n"
		"\n"
		"For some APIs that don't distinguish by entry point, this may be empty.\n"
		"\n"
		":param ShaderStage stage: The shader stage to fetch.\n"
		":return: The entry point name for the given shader.\n"
		":rtype: str\n"
		"\n"
		"" },
  { "GetShader", (PyCFunction) _wrap_PipeState_GetShader, METH_O, (char *) "\n"
		"GetShader(stage)\n"
		"\n"
		"Retrieves the object ID of the shader bound at a shader stage.\n"
		"\n"
		":param ShaderStage stage: The shader stage to fetch.\n"
		":return: The object ID for the given shader.\n"
		":rtype: ResourceId\n"
		"\n"
		"" },
  { "GetPrimitiveTopology", (PyCFunction) _wrap_PipeState_GetPrimitiveTopology, METH_NOARGS, (char *) "\n"
		"GetPrimitiveTopology()\n"
		"\n"
		"Returns the current primitive topology.\n"
		"\n"
		".. note::\n"
		"  On OpenGL the primitive topology is not part of any state, but is specified in each action.\n"
		"  In this case the current topology is whichever was last specified to a action, as if there was\n"
		"  implicit state set by a action.\n"
		"\n"
		":return: The current primitive topology.\n"
		":rtype: Topology\n"
		"\n"
		"" },
  { "GetIBuffer", (PyCFunction) _wrap_PipeState_GetIBuffer, METH_NOARGS, (char *) "\n"
		"GetIBuffer()\n"
		"\n"
		"Retrieves the current index buffer binding.\n"
		"\n"
		".. note::\n"
		"  On OpenGL the index stride/width is not part of any state, but is specified in each action.\n"
		"  In this case the current stride is whichever was last specified to a action, as if there was\n"
		"  implicit state set by a action.\n"
		"\n"
		":return: A :class:`BoundVBuffer` with the index buffer details\n"
		":rtype: BoundVBuffer\n"
		"\n"
		"" },
  { "IsRestartEnabled", (PyCFunction) _wrap_PipeState_IsRestartEnabled, METH_NOARGS, (char *) "\n"
		"IsRestartEnabled()\n"
		"\n"
		"Determines whether or not primitive restart is enabled.\n"
		"\n"
		":return: A boolean indicating if primitive restart is enabled.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "GetRestartIndex", (PyCFunction) _wrap_PipeState_GetRestartIndex, METH_NOARGS, (char *) "\n"
		"GetRestartIndex()\n"
		"\n"
		"Retrieves the primitive restart index.\n"
		"\n"
		":return: The index value that represents a primitive restart not a real index.\n"
		":rtype: int\n"
		"\n"
		"" },
  { "GetVBuffers", (PyCFunction) _wrap_PipeState_GetVBuffers, METH_NOARGS, (char *) "\n"
		"GetVBuffers()\n"
		"\n"
		"Retrieves the currently bound vertex buffers.\n"
		"\n"
		":return: The list of bound vertex buffers.\n"
		":rtype: List[BoundVBuffer]\n"
		"\n"
		"" },
  { "GetVertexInputs", (PyCFunction) _wrap_PipeState_GetVertexInputs, METH_NOARGS, (char *) "\n"
		"GetVertexInputs()\n"
		"\n"
		"Retrieves the currently specified vertex attributes.\n"
		"\n"
		":return: The list of current vertex attributes.\n"
		":rtype: List[VertexInputAttribute]\n"
		"\n"
		"" },
  { "GetDescriptorAccess", (PyCFunction) _wrap_PipeState_GetDescriptorAccess, METH_NOARGS, (char *) "\n"
		"GetDescriptorAccess()\n"
		"\n"
		"Retrieves the current list of descriptor accesses, as cached from a call to\n"
		":meth:`ReplayController.GetDescriptorAccess`. The return value is identical, this is here for\n"
		"convenience of access.\n"
		"\n"
		":return: The descriptor accesses.\n"
		":rtype: List[DescriptorAccess]\n"
		"\n"
		"" },
  { "GetAllUsedDescriptors", (PyCFunction) _wrap_PipeState_GetAllUsedDescriptors, METH_VARARGS, (char *) "\n"
		"GetAllUsedDescriptors(onlyUsed=False)\n"
		"GetAllUsedDescriptors()\n"
		"\n"
		"Retrieves all descriptor information for all descriptors accessed at the current event.\n"
		"\n"
		":param bool onlyUsed: Omit descriptors bound or declared but not accessed.\n"
		":return: All descriptors accessed at the current event.\n"
		":rtype: List[UsedDescriptor]\n"
		"\n"
		"" },
  { "GetConstantBlock", (PyCFunction) _wrap_PipeState_GetConstantBlock, METH_VARARGS, (char *) "\n"
		"GetConstantBlock(stage, index, arrayIdx)\n"
		"\n"
		"Retrieves the constant block at a given binding.\n"
		"\n"
		":param ShaderStage stage: The shader stage to fetch from.\n"
		":param int index: The index in the shader's ConstantBlocks array to look up.\n"
		":param int arrayIdx: For APIs that support arrays of constant buffers in a single binding, the index\n"
		"  in that array to look up.\n"
		":return: The constant buffer at the specified binding.\n"
		":rtype: UsedDescriptor\n"
		"\n"
		"" },
  { "GetConstantBlocks", (PyCFunction) _wrap_PipeState_GetConstantBlocks, METH_VARARGS, (char *) "\n"
		"GetConstantBlocks(stage, onlyUsed=False)\n"
		"GetConstantBlocks(stage)\n"
		"\n"
		"Retrieves the constant blocks used by a particular shader stage.\n"
		"\n"
		":param ShaderStage stage: The shader stage to fetch from.\n"
		":param bool onlyUsed: Omit descriptors bound or declared but not accessed.\n"
		":return: The currently bound constant blocks.\n"
		":rtype: List[UsedDescriptor]\n"
		"\n"
		"" },
  { "GetReadOnlyResources", (PyCFunction) _wrap_PipeState_GetReadOnlyResources, METH_VARARGS, (char *) "\n"
		"GetReadOnlyResources(stage, onlyUsed=False)\n"
		"GetReadOnlyResources(stage)\n"
		"\n"
		"Retrieves the read-only resources used by a particular shader stage.\n"
		"\n"
		":param ShaderStage stage: The shader stage to fetch from.\n"
		":param bool onlyUsed: Omit descriptors bound or declared but not accessed.\n"
		":return: The currently bound read-only resources.\n"
		":rtype: List[UsedDescriptor]\n"
		"\n"
		"" },
  { "GetSamplers", (PyCFunction) _wrap_PipeState_GetSamplers, METH_VARARGS, (char *) "\n"
		"GetSamplers(stage, onlyUsed=False)\n"
		"GetSamplers(stage)\n"
		"\n"
		"Retrieves the samplers bound to a particular shader stage.\n"
		"\n"
		":param ShaderStage stage: The shader stage to fetch from.\n"
		":param bool onlyUsed: Omit descriptors bound or declared but not accessed.\n"
		":return: The currently bound sampler resources.\n"
		":rtype: List[UsedDescriptor]\n"
		"\n"
		"" },
  { "GetReadWriteResources", (PyCFunction) _wrap_PipeState_GetReadWriteResources, METH_VARARGS, (char *) "\n"
		"GetReadWriteResources(stage, onlyUsed=False)\n"
		"GetReadWriteResources(stage)\n"
		"\n"
		"Retrieves the read/write resources used by a particular shader stage.\n"
		"\n"
		":param ShaderStage stage: The shader stage to fetch from.\n"
		":param bool onlyUsed: Omit descriptors bound or declared but not accessed.\n"
		":return: The currently bound read/write resources.\n"
		":rtype: List[UsedDescriptor]\n"
		"\n"
		"" },
  { "GetDepthTarget", (PyCFunction) _wrap_PipeState_GetDepthTarget, METH_NOARGS, (char *) "\n"
		"GetDepthTarget()\n"
		"\n"
		"Retrieves the read/write resources bound to the depth-stencil output.\n"
		"\n"
		":return: The currently bound depth-stencil resource.\n"
		":rtype: Descriptor\n"
		"\n"
		"" },
  { "GetDepthResolveTarget", (PyCFunction) _wrap_PipeState_GetDepthResolveTarget, METH_NOARGS, (char *) "\n"
		"GetDepthResolveTarget()\n"
		"\n"
		"Retrieves the read/write resources bound to the depth-stencil resolve output.\n"
		"\n"
		":return: The currently bound depth-stencil resolve resource.\n"
		":rtype: Descriptor\n"
		"\n"
		"" },
  { "GetOutputTargets", (PyCFunction) _wrap_PipeState_GetOutputTargets, METH_NOARGS, (char *) "\n"
		"GetOutputTargets()\n"
		"\n"
		"Retrieves the resources bound to the color outputs.\n"
		"\n"
		":return: The currently bound output targets.\n"
		":rtype: List[Descriptor]\n"
		"\n"
		"" },
  { "GetColorBlends", (PyCFunction) _wrap_PipeState_GetColorBlends, METH_NOARGS, (char *) "\n"
		"GetColorBlends()\n"
		"\n"
		"Retrieves the current color blending states, per target.\n"
		"\n"
		":return: The currently color blend states.\n"
		":rtype: List[ColorBlend]\n"
		"\n"
		"" },
  { "GetBlendFactor", (PyCFunction) _wrap_PipeState_GetBlendFactor, METH_NOARGS, (char *) "\n"
		"GetBlendFactor()\n"
		"\n"
		"Retrieves the current fixed blend factor.\n"
		"\n"
		":return: The currently fixed blend factor.\n"
		":rtype: Tuple[float,float,float,float]\n"
		"\n"
		"" },
  { "IsStencilTestEnabled", (PyCFunction) _wrap_PipeState_IsStencilTestEnabled, METH_NOARGS, (char *) "\n"
		"IsStencilTestEnabled()\n"
		"\n"
		"Checks whether stencil operations are enabled or not.\n"
		"\n"
		":return: ``True`` if stencil testing is enabled.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "GetStencilFaces", (PyCFunction) _wrap_PipeState_GetStencilFaces, METH_NOARGS, (char *) "\n"
		"GetStencilFaces()\n"
		"\n"
		"Retrieves the current stencil states.\n"
		"\n"
		":return: The currently stencil states. Front facing first, back facing second.\n"
		":rtype: Tuple[StencilFace, StencilFace]\n"
		"\n"
		"" },
  { "GetDepthTestState", (PyCFunction) _wrap_PipeState_GetDepthTestState, METH_NOARGS, (char *) "\n"
		"GetDepthTestState()\n"
		"\n"
		"Retrieves some of the depth testing state.\n"
		"\n"
		"This doesn't contain all properties from all APIs but a common subset.\n"
		"\n"
		":return: The currently depth testing state.\n"
		":rtype: DepthTestState\n"
		"\n"
		"" },
  { "GetRasterState", (PyCFunction) _wrap_PipeState_GetRasterState, METH_NOARGS, (char *) "\n"
		"GetRasterState()\n"
		"\n"
		"Retrieves some of the rasterizer state.\n"
		"\n"
		"This doesn't contain all properties from all APIs but a common subset.\n"
		"\n"
		":return: The currently depth testing state.\n"
		":rtype: RasterState\n"
		"\n"
		"" },
  { "IsIndependentBlendingEnabled", (PyCFunction) _wrap_PipeState_IsIndependentBlendingEnabled, METH_NOARGS, (char *) "\n"
		"IsIndependentBlendingEnabled()\n"
		"\n"
		"Determines whether or not independent blending is enabled.\n"
		"\n"
		":return: A boolean indicating if independent blending is enabled.\n"
		":rtype: bool\n"
		"\n"
		"" },
  { "GetShaderMessages", (PyCFunction) _wrap_PipeState_GetShaderMessages, METH_NOARGS, (char *) "\n"
		"GetShaderMessages()\n"
		"\n"
		"Retrieves the shader messages obtained for the current action.\n"
		"\n"
		":return: The shader messages obtained for the current action.\n"
		":rtype: List[ShaderMessage]\n"
		"\n"
		"" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__PipeState_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.PipeState",                    /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_PipeState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) 0,                             /* tp_repr */
    &SwigPyBuiltin__PipeState_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__PipeState_type.as_sequence,                   /* tp_as_sequence */
    &SwigPyBuiltin__PipeState_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) 0,                             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__PipeState_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "\n"
		"An API-agnostic view of the common aspects of the pipeline state. This allows simple\n"
		"access to e.g. find out the bound resources or vertex buffers, or certain pipeline state which is\n"
		"available on all APIs.\n"
		"\n"
		"For more detailed or precise information without abstraction, access the specific pipeline state\n"
		"for the capture that's open.\n"
		"\n"
		"",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__PipeState_richcompare,           /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__PipeState_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__PipeState_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) _wrap_new_PipeState,           /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) 0,                           /* mp_subscript */
    (objobjargproc) 0,                        /* mp_ass_subscript */
  },
  {
    (lenfunc) 0,                              /* sq_length */
    (binaryfunc) 0,                           /* sq_concat */
    (ssizeargfunc) 0,                         /* sq_repeat */
    (ssizeargfunc) 0,                         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) 0,                      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) 0,                           /* sq_inplace_concat */
    (ssizeargfunc) 0,                         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__PipeState_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__PipeState_type};

static SwigPyGetSet rdcarray_of_int___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_int_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(int)>.__dict__", (void *) &rdcarray_of_int___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_int_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_int___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_int___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_int___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_int_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_int___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_int___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_int___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_int_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_int_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_int_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_int_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_int_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_int_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_int_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_int_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_int_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_int_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_int_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_int_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_int_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_int_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_int_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_int_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_int_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_int",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_int_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_int,          /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_int_t_type.as_number,               /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_int_t_type.as_sequence,             /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_int_t_type.as_mapping,              /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_int,          /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_int_t_type.as_buffer,               /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< int >",                      /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_int_t_richcompare,     /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_int_t_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_int_t_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_int,/* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_int,                 /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_int,         /* sq_length */
    (binaryfunc) concat_rdcarray_of_int,      /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_int,    /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_int,   /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_int,/* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_int,  /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_int,/* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_int_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_int_t_type};

static SwigPyGetSet rdcarray_of_float___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_float_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(float)>.__dict__", (void *) &rdcarray_of_float___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_float_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_float___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_float___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_float___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_float_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_float___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_float___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_float___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_float_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_float_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_float_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_float_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_float_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_float_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_float_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_float_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_float_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_float_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_float_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_float_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_float_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_float_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_float_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_float_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_float_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_float",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_float_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_float,        /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_float_t_type.as_number,             /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_float_t_type.as_sequence,           /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_float_t_type.as_mapping,            /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_float,        /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_float_t_type.as_buffer,             /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< float >",                    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_float_t_richcompare,   /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_float_t_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_float_t_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_float,                  /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_float,               /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_float,       /* sq_length */
    (binaryfunc) concat_rdcarray_of_float,    /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_float,  /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_float, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_float,                  /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_float,/* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_float,                  /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_float_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_float_t_type};

static SwigPyGetSet rdcarray_of_uint32_t___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_uint32_t_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(uint32_t)>.__dict__", (void *) &rdcarray_of_uint32_t___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_uint32_t_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_uint32_t___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_uint32_t___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_uint32_t___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_uint32_t_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_uint32_t___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_uint32_t___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_uint32_t___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_uint32_t_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_uint32_t_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_uint32_t_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_uint32_t_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_uint32_t_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_uint32_t_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_uint32_t_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_uint32_t_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_uint32_t_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_uint32_t_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_uint32_t_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_uint32_t_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_uint32_t_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_uint32_t_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_uint32_t_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_uint32_t_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_uint32_t_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_uint32_t",         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_uint32_t_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_uint32_t,     /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_uint32_t_t_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_uint32_t_t_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_uint32_t_t_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_uint32_t,     /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_uint32_t_t_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< uint32_t >",                 /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_uint32_t_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_uint32_t_t_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_uint32_t_t_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_uint32_t,               /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_uint32_t,            /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_uint32_t,    /* sq_length */
    (binaryfunc) concat_rdcarray_of_uint32_t, /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_uint32_t,                   /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_uint32_t,                  /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_uint32_t,               /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_uint32_t,                 /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_uint32_t,               /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_uint32_t_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_uint32_t_t_type};

static SwigPyGetSet rdcarray_of_uint64_t___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_uint64_t_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(uint64_t)>.__dict__", (void *) &rdcarray_of_uint64_t___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_uint64_t_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_uint64_t___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_uint64_t___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_uint64_t___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_uint64_t_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_uint64_t___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_uint64_t___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_uint64_t___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_uint64_t_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_uint64_t_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_uint64_t_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_uint64_t_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_uint64_t_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_uint64_t_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_uint64_t_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_uint64_t_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_uint64_t_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_uint64_t_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_uint64_t_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_uint64_t_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_uint64_t_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_uint64_t_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_uint64_t_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_uint64_t_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_uint64_t_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_uint64_t",         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_uint64_t_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_uint64_t,     /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_uint64_t_t_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_uint64_t_t_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_uint64_t_t_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_uint64_t,     /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_uint64_t_t_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< uint64_t >",                 /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_uint64_t_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_uint64_t_t_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_uint64_t_t_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_uint64_t,               /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_uint64_t,            /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_uint64_t,    /* sq_length */
    (binaryfunc) concat_rdcarray_of_uint64_t, /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_uint64_t,                   /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_uint64_t,                  /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_uint64_t,               /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_uint64_t,                 /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_uint64_t,               /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_uint64_t_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_uint64_t_t_type};

static SwigPyGetSet rdcarray_of_rdcstr___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_rdcstr_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(rdcstr)>.__dict__", (void *) &rdcarray_of_rdcstr___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_rdcstr_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_rdcstr___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_rdcstr___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_rdcstr___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_rdcstr_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_rdcstr___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_rdcstr___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_rdcstr___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_rdcstr_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_rdcstr_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_rdcstr_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_rdcstr_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_rdcstr_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_rdcstr_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_rdcstr_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_rdcstr_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_rdcstr_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_rdcstr_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_rdcstr_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_rdcstr_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_rdcstr_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_rdcstr_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_rdcstr_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_rdcstr_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_rdcstr_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_rdcstr",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_rdcstr_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_rdcstr,       /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_rdcstr_t_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_rdcstr_t_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_rdcstr_t_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_rdcstr,       /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_rdcstr_t_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< rdcstr >",                   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_rdcstr_t_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_rdcstr_t_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_rdcstr_t_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_rdcstr,                 /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_rdcstr,              /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_rdcstr,      /* sq_length */
    (binaryfunc) concat_rdcarray_of_rdcstr,   /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_rdcstr, /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_rdcstr,/* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_rdcstr,                 /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_rdcstr,                   /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_rdcstr,                 /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_rdcstr_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_rdcstr_t_type};

static SwigPyGetSet rdcarray_of_WindowingSystem___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_WindowingSystem_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(WindowingSystem)>.__dict__", (void *) &rdcarray_of_WindowingSystem___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_WindowingSystem_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_WindowingSystem___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_WindowingSystem___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_WindowingSystem___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_WindowingSystem_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_WindowingSystem___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_WindowingSystem___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_WindowingSystem___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_WindowingSystem_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_WindowingSystem_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_WindowingSystem",  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_WindowingSystem_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_WindowingSystem,                  /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_WindowingSystem_t_type.as_number,   /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_WindowingSystem_t_type.as_sequence, /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_WindowingSystem_t_type.as_mapping,  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_WindowingSystem,                  /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_WindowingSystem_t_type.as_buffer,   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< WindowingSystem >",          /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_WindowingSystem_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_WindowingSystem_t_methods,           /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_WindowingSystem_t_getset,            /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_WindowingSystem,        /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_WindowingSystem,     /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_WindowingSystem,                 /* sq_length */
    (binaryfunc) concat_rdcarray_of_WindowingSystem,              /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_WindowingSystem,            /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_WindowingSystem,           /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_WindowingSystem,        /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_WindowingSystem,          /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_WindowingSystem,        /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_WindowingSystem_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_WindowingSystem_t_type};

static SwigPyGetSet rdcarray_of_ActionDescription___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ActionDescription_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ActionDescription)>.__dict__", (void *) &rdcarray_of_ActionDescription___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ActionDescription_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ActionDescription___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ActionDescription___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ActionDescription___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ActionDescription_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ActionDescription___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ActionDescription___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ActionDescription___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ActionDescription_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ActionDescription_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ActionDescription_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ActionDescription_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ActionDescription_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ActionDescription_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ActionDescription_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ActionDescription_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ActionDescription_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ActionDescription_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ActionDescription_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ActionDescription_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ActionDescription_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ActionDescription_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ActionDescription_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ActionDescription_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ActionDescription_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ActionDescription",/* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ActionDescription_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ActionDescription,                /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ActionDescription_t_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ActionDescription_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ActionDescription_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ActionDescription,                /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ActionDescription_t_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ActionDescription >",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ActionDescription_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ActionDescription_t_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ActionDescription_t_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ActionDescription,      /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ActionDescription,   /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ActionDescription,               /* sq_length */
    (binaryfunc) concat_rdcarray_of_ActionDescription,            /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ActionDescription,          /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ActionDescription,         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ActionDescription,      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ActionDescription,        /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ActionDescription,      /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ActionDescription_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ActionDescription_t_type};

static SwigPyGetSet rdcarray_of_GPUCounter___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_GPUCounter_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(GPUCounter)>.__dict__", (void *) &rdcarray_of_GPUCounter___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_GPUCounter_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_GPUCounter___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_GPUCounter___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_GPUCounter___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_GPUCounter_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_GPUCounter___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_GPUCounter___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_GPUCounter___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_GPUCounter_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_GPUCounter_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_GPUCounter_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_GPUCounter_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_GPUCounter_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_GPUCounter_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_GPUCounter_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_GPUCounter_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_GPUCounter_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_GPUCounter_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_GPUCounter_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_GPUCounter_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_GPUCounter_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_GPUCounter_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_GPUCounter_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_GPUCounter_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_GPUCounter_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_GPUCounter",       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_GPUCounter_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_GPUCounter,   /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_GPUCounter_t_type.as_number,        /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_GPUCounter_t_type.as_sequence,      /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_GPUCounter_t_type.as_mapping,       /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_GPUCounter,   /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_GPUCounter_t_type.as_buffer,        /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< GPUCounter >",               /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_GPUCounter_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_GPUCounter_t_methods,                /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_GPUCounter_t_getset,                 /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_GPUCounter,             /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_GPUCounter,          /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_GPUCounter,  /* sq_length */
    (binaryfunc) concat_rdcarray_of_GPUCounter,                   /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_GPUCounter,                 /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_GPUCounter,                /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_GPUCounter,             /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_GPUCounter,               /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_GPUCounter,             /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_GPUCounter_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_GPUCounter_t_type};

static SwigPyGetSet rdcarray_of_CounterResult___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_CounterResult_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(CounterResult)>.__dict__", (void *) &rdcarray_of_CounterResult___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_CounterResult_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_CounterResult___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_CounterResult___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_CounterResult___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_CounterResult_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_CounterResult___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_CounterResult___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_CounterResult___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_CounterResult_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_CounterResult_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_CounterResult_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_CounterResult_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_CounterResult_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_CounterResult_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_CounterResult_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_CounterResult_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_CounterResult_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_CounterResult_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_CounterResult_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_CounterResult_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_CounterResult_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_CounterResult_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_CounterResult_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_CounterResult_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_CounterResult_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_CounterResult",    /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_CounterResult_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_CounterResult,/* tp_repr */
    &SwigPyBuiltin__rdcarrayT_CounterResult_t_type.as_number,     /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_CounterResult_t_type.as_sequence,   /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_CounterResult_t_type.as_mapping,    /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_CounterResult,/* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_CounterResult_t_type.as_buffer,     /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< CounterResult >",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_CounterResult_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_CounterResult_t_methods,             /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_CounterResult_t_getset,              /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_CounterResult,          /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_CounterResult,       /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_CounterResult,                   /* sq_length */
    (binaryfunc) concat_rdcarray_of_CounterResult,                /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_CounterResult,              /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_CounterResult,             /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_CounterResult,          /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_CounterResult,            /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_CounterResult,          /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_CounterResult_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_CounterResult_t_type};

static SwigPyGetSet rdcarray_of_APIEvent___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_APIEvent_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(APIEvent)>.__dict__", (void *) &rdcarray_of_APIEvent___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_APIEvent_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_APIEvent___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_APIEvent___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_APIEvent___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_APIEvent_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_APIEvent___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_APIEvent___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_APIEvent___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_APIEvent_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_APIEvent_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_APIEvent_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_APIEvent_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_APIEvent_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_APIEvent_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_APIEvent_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_APIEvent_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_APIEvent_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_APIEvent_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_APIEvent_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_APIEvent_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_APIEvent_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_APIEvent_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_APIEvent_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_APIEvent_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_APIEvent_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_APIEvent",         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_APIEvent_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_APIEvent,     /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_APIEvent_t_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_APIEvent_t_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_APIEvent_t_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_APIEvent,     /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_APIEvent_t_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< APIEvent >",                 /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_APIEvent_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_APIEvent_t_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_APIEvent_t_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_APIEvent,               /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_APIEvent,            /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_APIEvent,    /* sq_length */
    (binaryfunc) concat_rdcarray_of_APIEvent, /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_APIEvent,                   /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_APIEvent,                  /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_APIEvent,               /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_APIEvent,                 /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_APIEvent,               /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_APIEvent_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_APIEvent_t_type};

static SwigPyGetSet rdcarray_of_DescriptorStoreDescription___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(DescriptorStoreDescription)>.__dict__", (void *) &rdcarray_of_DescriptorStoreDescription___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_DescriptorStoreDescription___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_DescriptorStoreDescription___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_DescriptorStoreDescription___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_DescriptorStoreDescription_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_DescriptorStoreDescription",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_DescriptorStoreDescription_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_DescriptorStoreDescription,       /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_DescriptorStoreDescription,       /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< DescriptorStoreDescription >",                   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_DescriptorStoreDescription,/* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_DescriptorStoreDescription,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_DescriptorStoreDescription,      /* sq_length */
    (binaryfunc) concat_rdcarray_of_DescriptorStoreDescription,   /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_DescriptorStoreDescription, /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_DescriptorStoreDescription,/* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_DescriptorStoreDescription,/* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_DescriptorStoreDescription,/* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_DescriptorStoreDescription,/* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_type};

static SwigPyGetSet rdcarray_of_BufferDescription___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_BufferDescription_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(BufferDescription)>.__dict__", (void *) &rdcarray_of_BufferDescription___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_BufferDescription_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_BufferDescription___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_BufferDescription___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_BufferDescription___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_BufferDescription_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_BufferDescription___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_BufferDescription___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_BufferDescription___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_BufferDescription_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_BufferDescription_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_BufferDescription_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_BufferDescription_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_BufferDescription_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_BufferDescription_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_BufferDescription_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_BufferDescription_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_BufferDescription_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_BufferDescription_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_BufferDescription_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_BufferDescription_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_BufferDescription_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_BufferDescription_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_BufferDescription_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_BufferDescription_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_BufferDescription_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_BufferDescription",/* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_BufferDescription_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_BufferDescription,                /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_BufferDescription_t_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_BufferDescription_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_BufferDescription_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_BufferDescription,                /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_BufferDescription_t_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< BufferDescription >",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_BufferDescription_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_BufferDescription_t_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_BufferDescription_t_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_BufferDescription,      /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_BufferDescription,   /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_BufferDescription,               /* sq_length */
    (binaryfunc) concat_rdcarray_of_BufferDescription,            /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_BufferDescription,          /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_BufferDescription,         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_BufferDescription,      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_BufferDescription,        /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_BufferDescription,      /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_BufferDescription_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_BufferDescription_t_type};

static SwigPyGetSet rdcarray_of_CaptureFileFormat___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(CaptureFileFormat)>.__dict__", (void *) &rdcarray_of_CaptureFileFormat___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_CaptureFileFormat___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_CaptureFileFormat___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_CaptureFileFormat___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_CaptureFileFormat_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_CaptureFileFormat",/* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_CaptureFileFormat_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_CaptureFileFormat,                /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_CaptureFileFormat,                /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< CaptureFileFormat >",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_CaptureFileFormat,      /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_CaptureFileFormat,   /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_CaptureFileFormat,               /* sq_length */
    (binaryfunc) concat_rdcarray_of_CaptureFileFormat,            /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_CaptureFileFormat,          /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_CaptureFileFormat,         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_CaptureFileFormat,      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_CaptureFileFormat,        /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_CaptureFileFormat,      /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_type};

static SwigPyGetSet rdcarray_of_ConstantBlock___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ConstantBlock_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ConstantBlock)>.__dict__", (void *) &rdcarray_of_ConstantBlock___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ConstantBlock_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ConstantBlock___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ConstantBlock___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ConstantBlock___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ConstantBlock_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ConstantBlock___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ConstantBlock___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ConstantBlock___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ConstantBlock_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ConstantBlock_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ConstantBlock",    /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ConstantBlock_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ConstantBlock,/* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ConstantBlock_t_type.as_number,     /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ConstantBlock_t_type.as_sequence,   /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ConstantBlock_t_type.as_mapping,    /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ConstantBlock,/* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ConstantBlock_t_type.as_buffer,     /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ConstantBlock >",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ConstantBlock_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ConstantBlock_t_methods,             /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ConstantBlock_t_getset,              /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ConstantBlock,          /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ConstantBlock,       /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ConstantBlock,                   /* sq_length */
    (binaryfunc) concat_rdcarray_of_ConstantBlock,                /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ConstantBlock,              /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ConstantBlock,             /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ConstantBlock,          /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ConstantBlock,            /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ConstantBlock,          /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ConstantBlock_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ConstantBlock_t_type};

static SwigPyGetSet rdcarray_of_DebugMessage___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_DebugMessage_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(DebugMessage)>.__dict__", (void *) &rdcarray_of_DebugMessage___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_DebugMessage_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_DebugMessage___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_DebugMessage___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_DebugMessage___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_DebugMessage_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_DebugMessage___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_DebugMessage___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_DebugMessage___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_DebugMessage_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_DebugMessage_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_DebugMessage_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_DebugMessage_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_DebugMessage_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_DebugMessage_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_DebugMessage_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_DebugMessage_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_DebugMessage_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_DebugMessage_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_DebugMessage_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_DebugMessage_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_DebugMessage_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_DebugMessage_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_DebugMessage_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_DebugMessage_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_DebugMessage_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_DebugMessage",     /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_DebugMessage_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_DebugMessage, /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_DebugMessage_t_type.as_number,      /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_DebugMessage_t_type.as_sequence,    /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_DebugMessage_t_type.as_mapping,     /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_DebugMessage, /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_DebugMessage_t_type.as_buffer,      /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< DebugMessage >",             /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_DebugMessage_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_DebugMessage_t_methods,              /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_DebugMessage_t_getset,               /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_DebugMessage,           /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_DebugMessage,        /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_DebugMessage,/* sq_length */
    (binaryfunc) concat_rdcarray_of_DebugMessage,                 /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_DebugMessage,               /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_DebugMessage,              /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_DebugMessage,           /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_DebugMessage,             /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_DebugMessage,           /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_DebugMessage_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_DebugMessage_t_type};

static SwigPyGetSet rdcarray_of_EnvironmentModification___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(EnvironmentModification)>.__dict__", (void *) &rdcarray_of_EnvironmentModification___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_EnvironmentModification___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_EnvironmentModification___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_EnvironmentModification___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_EnvironmentModification_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_EnvironmentModification",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_EnvironmentModification_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_EnvironmentModification,          /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_EnvironmentModification,          /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< EnvironmentModification >",  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_EnvironmentModification,/* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_EnvironmentModification,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_EnvironmentModification,         /* sq_length */
    (binaryfunc) concat_rdcarray_of_EnvironmentModification,      /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_EnvironmentModification,    /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_EnvironmentModification,   /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_EnvironmentModification,/* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_EnvironmentModification,  /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_EnvironmentModification,/* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_type};

static SwigPyGetSet rdcarray_of_EventUsage___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_EventUsage_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(EventUsage)>.__dict__", (void *) &rdcarray_of_EventUsage___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_EventUsage_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_EventUsage___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_EventUsage___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_EventUsage___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_EventUsage_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_EventUsage___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_EventUsage___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_EventUsage___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_EventUsage_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_EventUsage_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_EventUsage_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_EventUsage_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_EventUsage_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_EventUsage_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_EventUsage_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_EventUsage_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_EventUsage_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_EventUsage_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_EventUsage_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_EventUsage_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_EventUsage_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_EventUsage_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_EventUsage_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_EventUsage_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_EventUsage_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_EventUsage",       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_EventUsage_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_EventUsage,   /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_EventUsage_t_type.as_number,        /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_EventUsage_t_type.as_sequence,      /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_EventUsage_t_type.as_mapping,       /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_EventUsage,   /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_EventUsage_t_type.as_buffer,        /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< EventUsage >",               /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_EventUsage_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_EventUsage_t_methods,                /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_EventUsage_t_getset,                 /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_EventUsage,             /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_EventUsage,          /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_EventUsage,  /* sq_length */
    (binaryfunc) concat_rdcarray_of_EventUsage,                   /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_EventUsage,                 /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_EventUsage,                /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_EventUsage,             /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_EventUsage,               /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_EventUsage,             /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_EventUsage_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_EventUsage_t_type};

static SwigPyGetSet rdcarray_of_PathEntry___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_PathEntry_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(PathEntry)>.__dict__", (void *) &rdcarray_of_PathEntry___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_PathEntry_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_PathEntry___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_PathEntry___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_PathEntry___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_PathEntry_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_PathEntry___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_PathEntry___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_PathEntry___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_PathEntry_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_PathEntry_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_PathEntry_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_PathEntry_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_PathEntry_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_PathEntry_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_PathEntry_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_PathEntry_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_PathEntry_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_PathEntry_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_PathEntry_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_PathEntry_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_PathEntry_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_PathEntry_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_PathEntry_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_PathEntry_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_PathEntry_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_PathEntry",        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_PathEntry_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_PathEntry,    /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_PathEntry_t_type.as_number,         /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_PathEntry_t_type.as_sequence,       /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_PathEntry_t_type.as_mapping,        /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_PathEntry,    /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_PathEntry_t_type.as_buffer,         /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< PathEntry >",                /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_PathEntry_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_PathEntry_t_methods,                 /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_PathEntry_t_getset,                  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_PathEntry,              /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_PathEntry,           /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_PathEntry,   /* sq_length */
    (binaryfunc) concat_rdcarray_of_PathEntry,/* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_PathEntry,                  /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_PathEntry,                 /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_PathEntry,              /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_PathEntry,                /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_PathEntry,              /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_PathEntry_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_PathEntry_t_type};

static SwigPyGetSet rdcarray_of_PixelModification___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_PixelModification_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(PixelModification)>.__dict__", (void *) &rdcarray_of_PixelModification___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_PixelModification_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_PixelModification___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_PixelModification___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_PixelModification___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_PixelModification_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_PixelModification___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_PixelModification___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_PixelModification___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_PixelModification_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_PixelModification_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_PixelModification_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_PixelModification_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_PixelModification_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_PixelModification_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_PixelModification_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_PixelModification_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_PixelModification_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_PixelModification_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_PixelModification_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_PixelModification_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_PixelModification_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_PixelModification_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_PixelModification_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_PixelModification_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_PixelModification_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_PixelModification",/* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_PixelModification_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_PixelModification,                /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_PixelModification_t_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_PixelModification_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_PixelModification_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_PixelModification,                /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_PixelModification_t_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< PixelModification >",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_PixelModification_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_PixelModification_t_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_PixelModification_t_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_PixelModification,      /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_PixelModification,   /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_PixelModification,               /* sq_length */
    (binaryfunc) concat_rdcarray_of_PixelModification,            /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_PixelModification,          /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_PixelModification,         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_PixelModification,      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_PixelModification,        /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_PixelModification,      /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_PixelModification_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_PixelModification_t_type};

static SwigPyGetSet rdcarray_of_TaskGroupSize___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(TaskGroupSize)>.__dict__", (void *) &rdcarray_of_TaskGroupSize___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_TaskGroupSize___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_TaskGroupSize___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_TaskGroupSize___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_TaskGroupSize_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_TaskGroupSize",    /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_TaskGroupSize_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_TaskGroupSize,/* tp_repr */
    &SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_type.as_number,     /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_type.as_sequence,   /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_type.as_mapping,    /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_TaskGroupSize,/* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_type.as_buffer,     /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< TaskGroupSize >",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_methods,             /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_getset,              /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_TaskGroupSize,          /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_TaskGroupSize,       /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_TaskGroupSize,                   /* sq_length */
    (binaryfunc) concat_rdcarray_of_TaskGroupSize,                /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_TaskGroupSize,              /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_TaskGroupSize,             /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_TaskGroupSize,          /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_TaskGroupSize,            /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_TaskGroupSize,          /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_type};

static SwigPyGetSet rdcarray_of_MeshletSize___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_MeshletSize_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(MeshletSize)>.__dict__", (void *) &rdcarray_of_MeshletSize___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_MeshletSize_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_MeshletSize___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_MeshletSize___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_MeshletSize___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_MeshletSize_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_MeshletSize___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_MeshletSize___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_MeshletSize___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_MeshletSize_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_MeshletSize_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_MeshletSize_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_MeshletSize_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_MeshletSize_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_MeshletSize_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_MeshletSize_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_MeshletSize_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_MeshletSize_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_MeshletSize_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_MeshletSize_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_MeshletSize_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_MeshletSize_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_MeshletSize_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_MeshletSize_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_MeshletSize_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_MeshletSize_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_MeshletSize",      /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_MeshletSize_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_MeshletSize,  /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_MeshletSize_t_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_MeshletSize_t_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_MeshletSize_t_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_MeshletSize,  /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_MeshletSize_t_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< MeshletSize >",              /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_MeshletSize_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_MeshletSize_t_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_MeshletSize_t_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_MeshletSize,            /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_MeshletSize,         /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_MeshletSize, /* sq_length */
    (binaryfunc) concat_rdcarray_of_MeshletSize,                  /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_MeshletSize,                /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_MeshletSize,               /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_MeshletSize,            /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_MeshletSize,              /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_MeshletSize,            /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_MeshletSize_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_MeshletSize_t_type};

static SwigPyGetSet rdcarray_of_ResourceDescription___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ResourceDescription_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ResourceDescription)>.__dict__", (void *) &rdcarray_of_ResourceDescription___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ResourceDescription_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ResourceDescription___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ResourceDescription___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ResourceDescription___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ResourceDescription_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ResourceDescription___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ResourceDescription___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ResourceDescription___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ResourceDescription_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ResourceDescription_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ResourceDescription",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ResourceDescription_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ResourceDescription,              /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ResourceDescription_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ResourceDescription_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ResourceDescription_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ResourceDescription,              /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ResourceDescription_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ResourceDescription >",      /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ResourceDescription_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ResourceDescription_t_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ResourceDescription_t_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ResourceDescription,    /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ResourceDescription, /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ResourceDescription,             /* sq_length */
    (binaryfunc) concat_rdcarray_of_ResourceDescription,          /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ResourceDescription,        /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ResourceDescription,       /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ResourceDescription,    /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ResourceDescription,      /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ResourceDescription,    /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ResourceDescription_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ResourceDescription_t_type};

static SwigPyGetSet rdcarray_of_ResourceId___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ResourceId_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ResourceId)>.__dict__", (void *) &rdcarray_of_ResourceId___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ResourceId_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ResourceId___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ResourceId___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ResourceId___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ResourceId_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ResourceId___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ResourceId___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ResourceId___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ResourceId_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ResourceId_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ResourceId_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ResourceId_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ResourceId_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ResourceId_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ResourceId_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ResourceId_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ResourceId_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ResourceId_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ResourceId_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ResourceId_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ResourceId_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ResourceId_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ResourceId_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ResourceId_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ResourceId_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ResourceId",       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ResourceId_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ResourceId,   /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ResourceId_t_type.as_number,        /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ResourceId_t_type.as_sequence,      /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ResourceId_t_type.as_mapping,       /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ResourceId,   /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ResourceId_t_type.as_buffer,        /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ResourceId >",               /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ResourceId_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ResourceId_t_methods,                /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ResourceId_t_getset,                 /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ResourceId,             /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ResourceId,          /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ResourceId,  /* sq_length */
    (binaryfunc) concat_rdcarray_of_ResourceId,                   /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ResourceId,                 /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ResourceId,                /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ResourceId,             /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ResourceId,               /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ResourceId,             /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ResourceId_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ResourceId_t_type};

static SwigPyGetSet rdcarray_of_LineColumnInfo___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(LineColumnInfo)>.__dict__", (void *) &rdcarray_of_LineColumnInfo___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_LineColumnInfo___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_LineColumnInfo___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_LineColumnInfo___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_LineColumnInfo_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_LineColumnInfo",   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_LineColumnInfo_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_LineColumnInfo,                   /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_LineColumnInfo,                   /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< LineColumnInfo >",           /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_LineColumnInfo,         /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_LineColumnInfo,      /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_LineColumnInfo,                  /* sq_length */
    (binaryfunc) concat_rdcarray_of_LineColumnInfo,               /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_LineColumnInfo,             /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_LineColumnInfo,            /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_LineColumnInfo,         /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_LineColumnInfo,           /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_LineColumnInfo,         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_type};

static SwigPyGetSet rdcarray_of_InstructionSourceInfo___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(InstructionSourceInfo)>.__dict__", (void *) &rdcarray_of_InstructionSourceInfo___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_InstructionSourceInfo___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_InstructionSourceInfo___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_InstructionSourceInfo___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_InstructionSourceInfo_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_InstructionSourceInfo",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_InstructionSourceInfo_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_InstructionSourceInfo,            /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_InstructionSourceInfo,            /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< InstructionSourceInfo >",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_InstructionSourceInfo,  /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_InstructionSourceInfo,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_InstructionSourceInfo,           /* sq_length */
    (binaryfunc) concat_rdcarray_of_InstructionSourceInfo,        /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_InstructionSourceInfo,      /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_InstructionSourceInfo,     /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_InstructionSourceInfo,  /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_InstructionSourceInfo,    /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_InstructionSourceInfo,  /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_type};

static SwigPyGetSet rdcarray_of_ShaderCompileFlag___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderCompileFlag)>.__dict__", (void *) &rdcarray_of_ShaderCompileFlag___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderCompileFlag___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderCompileFlag___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderCompileFlag___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderCompileFlag_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderCompileFlag",/* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderCompileFlag_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderCompileFlag,                /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderCompileFlag,                /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderCompileFlag >",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderCompileFlag,      /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderCompileFlag,   /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderCompileFlag,               /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderCompileFlag,            /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderCompileFlag,          /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderCompileFlag,         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderCompileFlag,      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderCompileFlag,        /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderCompileFlag,      /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_type};

static SwigPyGetSet rdcarray_of_ShaderConstant___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderConstant_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderConstant)>.__dict__", (void *) &rdcarray_of_ShaderConstant___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderConstant_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderConstant___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderConstant___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderConstant___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderConstant_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderConstant___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderConstant___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderConstant___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderConstant_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderConstant_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderConstant",   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderConstant_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderConstant,                   /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderConstant_t_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderConstant_t_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderConstant_t_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderConstant,                   /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderConstant_t_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderConstant >",           /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderConstant_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderConstant_t_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderConstant_t_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderConstant,         /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderConstant,      /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderConstant,                  /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderConstant,               /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderConstant,             /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderConstant,            /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderConstant,         /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderConstant,           /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderConstant,         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderConstant_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderConstant_t_type};

static SwigPyGetSet rdcarray_of_ShaderDebugState___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderDebugState)>.__dict__", (void *) &rdcarray_of_ShaderDebugState___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderDebugState___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderDebugState___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderDebugState___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderDebugState_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderDebugState", /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderDebugState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderDebugState,                 /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderDebugState,                 /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderDebugState >",         /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderDebugState,       /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderDebugState,    /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderDebugState,                /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderDebugState,             /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderDebugState,           /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderDebugState,          /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderDebugState,       /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderDebugState,         /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderDebugState,       /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_type};

static SwigPyGetSet rdcarray_of_ShaderMessage___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderMessage_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderMessage)>.__dict__", (void *) &rdcarray_of_ShaderMessage___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderMessage_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderMessage___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderMessage___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderMessage___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderMessage_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderMessage___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderMessage___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderMessage___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderMessage_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderMessage_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderMessage",    /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderMessage_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderMessage,/* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderMessage_t_type.as_number,     /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderMessage_t_type.as_sequence,   /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderMessage_t_type.as_mapping,    /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderMessage,/* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderMessage_t_type.as_buffer,     /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderMessage >",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderMessage_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderMessage_t_methods,             /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderMessage_t_getset,              /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderMessage,          /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderMessage,       /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderMessage,                   /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderMessage,                /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderMessage,              /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderMessage,             /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderMessage,          /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderMessage,            /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderMessage,          /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderMessage_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderMessage_t_type};

static SwigPyGetSet rdcarray_of_ShaderResource___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderResource_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderResource)>.__dict__", (void *) &rdcarray_of_ShaderResource___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderResource_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderResource___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderResource___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderResource___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderResource_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderResource___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderResource___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderResource___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderResource_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderResource_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderResource_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderResource_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderResource_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderResource_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderResource_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderResource_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderResource_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderResource_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderResource_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderResource_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderResource_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderResource_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderResource_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderResource_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderResource_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderResource",   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderResource_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderResource,                   /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderResource_t_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderResource_t_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderResource_t_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderResource,                   /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderResource_t_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderResource >",           /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderResource_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderResource_t_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderResource_t_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderResource,         /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderResource,      /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderResource,                  /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderResource,               /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderResource,             /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderResource,            /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderResource,         /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderResource,           /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderResource,         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderResource_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderResource_t_type};

static SwigPyGetSet rdcarray_of_ShaderSampler___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderSampler_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderSampler)>.__dict__", (void *) &rdcarray_of_ShaderSampler___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderSampler_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderSampler___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderSampler___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderSampler___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderSampler_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderSampler___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderSampler___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderSampler___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderSampler_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderSampler_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderSampler",    /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderSampler_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderSampler,/* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderSampler_t_type.as_number,     /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderSampler_t_type.as_sequence,   /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderSampler_t_type.as_mapping,    /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderSampler,/* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderSampler_t_type.as_buffer,     /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderSampler >",            /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderSampler_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderSampler_t_methods,             /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderSampler_t_getset,              /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderSampler,          /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderSampler,       /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderSampler,                   /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderSampler,                /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderSampler,              /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderSampler,             /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderSampler,          /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderSampler,            /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderSampler,          /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderSampler_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderSampler_t_type};

static SwigPyGetSet rdcarray_of_ShaderSourceFile___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderSourceFile)>.__dict__", (void *) &rdcarray_of_ShaderSourceFile___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderSourceFile___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderSourceFile___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderSourceFile___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderSourceFile_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderSourceFile", /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderSourceFile_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderSourceFile,                 /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderSourceFile,                 /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderSourceFile >",         /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderSourceFile,       /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderSourceFile,    /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderSourceFile,                /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderSourceFile,             /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderSourceFile,           /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderSourceFile,          /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderSourceFile,       /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderSourceFile,         /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderSourceFile,       /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_type};

static SwigPyGetSet rdcarray_of_ShaderSourcePrefix___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderSourcePrefix)>.__dict__", (void *) &rdcarray_of_ShaderSourcePrefix___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderSourcePrefix___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderSourcePrefix___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderSourcePrefix___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderSourcePrefix_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderSourcePrefix",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderSourcePrefix_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderSourcePrefix,               /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderSourcePrefix,               /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderSourcePrefix >",       /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderSourcePrefix,     /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderSourcePrefix,  /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderSourcePrefix,              /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderSourcePrefix,           /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderSourcePrefix,         /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderSourcePrefix,        /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderSourcePrefix,     /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderSourcePrefix,       /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderSourcePrefix,     /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_type};

static SwigPyGetSet rdcarray_of_ShaderVariable___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderVariable_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderVariable)>.__dict__", (void *) &rdcarray_of_ShaderVariable___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderVariable_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderVariable___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderVariable___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderVariable___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderVariable_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderVariable___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderVariable___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderVariable___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderVariable_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderVariable_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderVariable",   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderVariable_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderVariable,                   /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderVariable_t_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderVariable_t_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderVariable_t_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderVariable,                   /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderVariable_t_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderVariable >",           /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderVariable_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderVariable_t_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderVariable_t_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderVariable,         /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderVariable,      /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderVariable,                  /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderVariable,               /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderVariable,             /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderVariable,            /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderVariable,         /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderVariable,           /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderVariable,         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderVariable_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderVariable_t_type};

static SwigPyGetSet rdcarray_of_ShaderEncoding___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderEncoding)>.__dict__", (void *) &rdcarray_of_ShaderEncoding___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderEncoding___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderEncoding___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderEncoding___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderEncoding_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderEncoding",   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderEncoding_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderEncoding,                   /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderEncoding,                   /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderEncoding >",           /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderEncoding,         /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderEncoding,      /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderEncoding,                  /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderEncoding,               /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderEncoding,             /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderEncoding,            /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderEncoding,         /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderEncoding,           /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderEncoding,         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_type};

static SwigPyGetSet rdcarray_of_ShaderVariableChange___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderVariableChange)>.__dict__", (void *) &rdcarray_of_ShaderVariableChange___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderVariableChange___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderVariableChange___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderVariableChange___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderVariableChange_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderVariableChange",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderVariableChange_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderVariableChange,             /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderVariableChange,             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderVariableChange >",     /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderVariableChange,   /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderVariableChange,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderVariableChange,            /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderVariableChange,         /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderVariableChange,       /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderVariableChange,      /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderVariableChange,   /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderVariableChange,     /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderVariableChange,   /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_type};

static SwigPyGetSet rdcarray_of_DebugVariableReference___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(DebugVariableReference)>.__dict__", (void *) &rdcarray_of_DebugVariableReference___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_DebugVariableReference___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_DebugVariableReference___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_DebugVariableReference___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_DebugVariableReference_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_DebugVariableReference",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_DebugVariableReference_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_DebugVariableReference,           /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_DebugVariableReference,           /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< DebugVariableReference >",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_methods,    /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_getset,     /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_DebugVariableReference, /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_DebugVariableReference,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_DebugVariableReference,          /* sq_length */
    (binaryfunc) concat_rdcarray_of_DebugVariableReference,       /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_DebugVariableReference,     /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_DebugVariableReference,    /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_DebugVariableReference, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_DebugVariableReference,   /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_DebugVariableReference, /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_type};

static SwigPyGetSet rdcarray_of_SourceVariableMapping___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(SourceVariableMapping)>.__dict__", (void *) &rdcarray_of_SourceVariableMapping___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_SourceVariableMapping___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_SourceVariableMapping___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_SourceVariableMapping___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_SourceVariableMapping_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_SourceVariableMapping",                /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_SourceVariableMapping_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_SourceVariableMapping,            /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_SourceVariableMapping,            /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< SourceVariableMapping >",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_SourceVariableMapping,  /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_SourceVariableMapping,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_SourceVariableMapping,           /* sq_length */
    (binaryfunc) concat_rdcarray_of_SourceVariableMapping,        /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_SourceVariableMapping,      /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_SourceVariableMapping,     /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_SourceVariableMapping,  /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_SourceVariableMapping,    /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_SourceVariableMapping,  /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_type};

static SwigPyGetSet rdcarray_of_SigParameter___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_SigParameter_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(SigParameter)>.__dict__", (void *) &rdcarray_of_SigParameter___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_SigParameter_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_SigParameter___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_SigParameter___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_SigParameter___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_SigParameter_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_SigParameter___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_SigParameter___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_SigParameter___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_SigParameter_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_SigParameter_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_SigParameter_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_SigParameter_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_SigParameter_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_SigParameter_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_SigParameter_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_SigParameter_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_SigParameter_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_SigParameter_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_SigParameter_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_SigParameter_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_SigParameter_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_SigParameter_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_SigParameter_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_SigParameter_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_SigParameter_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_SigParameter",     /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_SigParameter_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_SigParameter, /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_SigParameter_t_type.as_number,      /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_SigParameter_t_type.as_sequence,    /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_SigParameter_t_type.as_mapping,     /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_SigParameter, /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_SigParameter_t_type.as_buffer,      /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< SigParameter >",             /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_SigParameter_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_SigParameter_t_methods,              /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_SigParameter_t_getset,               /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_SigParameter,           /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_SigParameter,        /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_SigParameter,/* sq_length */
    (binaryfunc) concat_rdcarray_of_SigParameter,                 /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_SigParameter,               /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_SigParameter,              /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_SigParameter,           /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_SigParameter,             /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_SigParameter,           /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_SigParameter_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_SigParameter_t_type};

static SwigPyGetSet rdcarray_of_TextureDescription___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_TextureDescription_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(TextureDescription)>.__dict__", (void *) &rdcarray_of_TextureDescription___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_TextureDescription_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_TextureDescription___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_TextureDescription___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_TextureDescription___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_TextureDescription_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_TextureDescription___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_TextureDescription___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_TextureDescription___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_TextureDescription_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_TextureDescription_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_TextureDescription_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_TextureDescription_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_TextureDescription_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_TextureDescription_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_TextureDescription_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_TextureDescription_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_TextureDescription_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_TextureDescription_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_TextureDescription_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_TextureDescription_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_TextureDescription_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_TextureDescription_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_TextureDescription_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_TextureDescription_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_TextureDescription_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_TextureDescription",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_TextureDescription_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_TextureDescription,               /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_TextureDescription_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_TextureDescription_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_TextureDescription_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_TextureDescription,               /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_TextureDescription_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< TextureDescription >",       /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_TextureDescription_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_TextureDescription_t_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_TextureDescription_t_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_TextureDescription,     /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_TextureDescription,  /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_TextureDescription,              /* sq_length */
    (binaryfunc) concat_rdcarray_of_TextureDescription,           /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_TextureDescription,         /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_TextureDescription,        /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_TextureDescription,     /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_TextureDescription,       /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_TextureDescription,     /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_TextureDescription_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_TextureDescription_t_type};

static SwigPyGetSet rdcarray_of_ShaderEntryPoint___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderEntryPoint)>.__dict__", (void *) &rdcarray_of_ShaderEntryPoint___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderEntryPoint___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderEntryPoint___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderEntryPoint___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderEntryPoint_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderEntryPoint", /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderEntryPoint_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderEntryPoint,                 /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderEntryPoint,                 /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderEntryPoint >",         /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderEntryPoint,       /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderEntryPoint,    /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderEntryPoint,                /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderEntryPoint,             /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderEntryPoint,           /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderEntryPoint,          /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderEntryPoint,       /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderEntryPoint,         /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderEntryPoint,       /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_type};

static SwigPyGetSet rdcarray_of_Viewport___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_Viewport_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(Viewport)>.__dict__", (void *) &rdcarray_of_Viewport___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_Viewport_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_Viewport___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_Viewport___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_Viewport___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_Viewport_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_Viewport___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_Viewport___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_Viewport___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_Viewport_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_Viewport_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_Viewport_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_Viewport_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_Viewport_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_Viewport_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_Viewport_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_Viewport_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_Viewport_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_Viewport_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_Viewport_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_Viewport_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_Viewport_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_Viewport_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_Viewport_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_Viewport_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_Viewport_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_Viewport",         /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_Viewport_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_Viewport,     /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_Viewport_t_type.as_number,          /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_Viewport_t_type.as_sequence,        /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_Viewport_t_type.as_mapping,         /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_Viewport,     /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_Viewport_t_type.as_buffer,          /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< Viewport >",                 /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_Viewport_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_Viewport_t_methods,                  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_Viewport_t_getset,                   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_Viewport,               /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_Viewport,            /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_Viewport,    /* sq_length */
    (binaryfunc) concat_rdcarray_of_Viewport, /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_Viewport,                   /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_Viewport,                  /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_Viewport,               /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_Viewport,                 /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_Viewport,               /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_Viewport_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_Viewport_t_type};

static SwigPyGetSet rdcarray_of_Scissor___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_Scissor_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(Scissor)>.__dict__", (void *) &rdcarray_of_Scissor___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_Scissor_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_Scissor___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_Scissor___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_Scissor___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_Scissor_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_Scissor___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_Scissor___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_Scissor___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_Scissor_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_Scissor_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_Scissor_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_Scissor_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_Scissor_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_Scissor_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_Scissor_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_Scissor_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_Scissor_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_Scissor_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_Scissor_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_Scissor_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_Scissor_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_Scissor_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_Scissor_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_Scissor_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_Scissor_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_Scissor",          /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_Scissor_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_Scissor,      /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_Scissor_t_type.as_number,           /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_Scissor_t_type.as_sequence,         /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_Scissor_t_type.as_mapping,          /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_Scissor,      /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_Scissor_t_type.as_buffer,           /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< Scissor >",                  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_Scissor_t_richcompare, /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_Scissor_t_methods,                   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_Scissor_t_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_Scissor,                /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_Scissor,             /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_Scissor,     /* sq_length */
    (binaryfunc) concat_rdcarray_of_Scissor,  /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_Scissor,/* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_Scissor,                   /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_Scissor,                /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_Scissor,                  /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_Scissor,                /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_Scissor_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_Scissor_t_type};

static SwigPyGetSet rdcarray_of_ColorBlend___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ColorBlend_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ColorBlend)>.__dict__", (void *) &rdcarray_of_ColorBlend___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ColorBlend_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ColorBlend___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ColorBlend___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ColorBlend___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ColorBlend_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ColorBlend___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ColorBlend___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ColorBlend___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ColorBlend_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ColorBlend_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ColorBlend_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ColorBlend_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ColorBlend_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ColorBlend_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ColorBlend_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ColorBlend_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ColorBlend_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ColorBlend_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ColorBlend_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ColorBlend_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ColorBlend_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ColorBlend_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ColorBlend_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ColorBlend_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ColorBlend_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ColorBlend",       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ColorBlend_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ColorBlend,   /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ColorBlend_t_type.as_number,        /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ColorBlend_t_type.as_sequence,      /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ColorBlend_t_type.as_mapping,       /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ColorBlend,   /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ColorBlend_t_type.as_buffer,        /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ColorBlend >",               /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ColorBlend_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ColorBlend_t_methods,                /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ColorBlend_t_getset,                 /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ColorBlend,             /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ColorBlend,          /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ColorBlend,  /* sq_length */
    (binaryfunc) concat_rdcarray_of_ColorBlend,                   /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ColorBlend,                 /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ColorBlend,                /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ColorBlend,             /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ColorBlend,               /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ColorBlend,             /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ColorBlend_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ColorBlend_t_type};

static SwigPyGetSet rdcarray_of_BoundVBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(BoundVBuffer)>.__dict__", (void *) &rdcarray_of_BoundVBuffer___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_BoundVBuffer___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_BoundVBuffer___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_BoundVBuffer___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_BoundVBuffer_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_BoundVBuffer",     /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_BoundVBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_BoundVBuffer, /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_type.as_number,      /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_type.as_sequence,    /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_type.as_mapping,     /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_BoundVBuffer, /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_type.as_buffer,      /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< BoundVBuffer >",             /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_methods,              /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_getset,               /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_BoundVBuffer,           /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_BoundVBuffer,        /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_BoundVBuffer,/* sq_length */
    (binaryfunc) concat_rdcarray_of_BoundVBuffer,                 /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_BoundVBuffer,               /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_BoundVBuffer,              /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_BoundVBuffer,           /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_BoundVBuffer,             /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_BoundVBuffer,           /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_type};

static SwigPyGetSet rdcarray_of_Offset___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_Offset_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(Offset)>.__dict__", (void *) &rdcarray_of_Offset___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_Offset_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_Offset___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_Offset___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_Offset___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_Offset_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_Offset___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_Offset___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_Offset___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_Offset_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_Offset_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_Offset_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_Offset_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_Offset_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_Offset_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_Offset_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_Offset_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_Offset_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_Offset_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_Offset_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_Offset_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_Offset_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_Offset_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_Offset_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_Offset_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_Offset_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_Offset",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_Offset_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_Offset,       /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_Offset_t_type.as_number,            /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_Offset_t_type.as_sequence,          /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_Offset_t_type.as_mapping,           /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_Offset,       /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_Offset_t_type.as_buffer,            /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< Offset >",                   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_Offset_t_richcompare,  /* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_Offset_t_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_Offset_t_getset, /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_Offset,                 /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_Offset,              /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_Offset,      /* sq_length */
    (binaryfunc) concat_rdcarray_of_Offset,   /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_Offset, /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_Offset,/* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_Offset,                 /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_Offset,                   /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_Offset,                 /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_Offset_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_Offset_t_type};

static SwigPyGetSet rdcarray_of_VertexInputAttribute___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(VertexInputAttribute)>.__dict__", (void *) &rdcarray_of_VertexInputAttribute___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_VertexInputAttribute___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_VertexInputAttribute___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_VertexInputAttribute___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_VertexInputAttribute_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_VertexInputAttribute",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_VertexInputAttribute_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_VertexInputAttribute,             /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_VertexInputAttribute,             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< VertexInputAttribute >",     /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_VertexInputAttribute,   /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_VertexInputAttribute,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_VertexInputAttribute,            /* sq_length */
    (binaryfunc) concat_rdcarray_of_VertexInputAttribute,         /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_VertexInputAttribute,       /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_VertexInputAttribute,      /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_VertexInputAttribute,   /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_VertexInputAttribute,     /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_VertexInputAttribute,   /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_type};

static SwigPyGetSet rdcarray_of_FloatVector___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_FloatVector_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(FloatVector)>.__dict__", (void *) &rdcarray_of_FloatVector___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_FloatVector_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_FloatVector___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_FloatVector___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_FloatVector___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_FloatVector_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_FloatVector___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_FloatVector___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_FloatVector___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_FloatVector_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_FloatVector_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_FloatVector_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_FloatVector_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_FloatVector_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_FloatVector_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_FloatVector_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_FloatVector_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_FloatVector_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_FloatVector_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_FloatVector_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_FloatVector_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_FloatVector_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_FloatVector_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_FloatVector_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_FloatVector_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_FloatVector_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_FloatVector",      /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_FloatVector_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_FloatVector,  /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_FloatVector_t_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_FloatVector_t_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_FloatVector_t_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_FloatVector,  /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_FloatVector_t_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< FloatVector >",              /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_FloatVector_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_FloatVector_t_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_FloatVector_t_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_FloatVector,            /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_FloatVector,         /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_FloatVector, /* sq_length */
    (binaryfunc) concat_rdcarray_of_FloatVector,                  /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_FloatVector,                /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_FloatVector,               /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_FloatVector,            /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_FloatVector,              /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_FloatVector,            /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_FloatVector_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_FloatVector_t_type};

static SwigPyGetSet rdcarray_of_GraphicsAPI___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(GraphicsAPI)>.__dict__", (void *) &rdcarray_of_GraphicsAPI___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_GraphicsAPI___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_GraphicsAPI___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_GraphicsAPI___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_GraphicsAPI_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_GraphicsAPI",      /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_GraphicsAPI_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_GraphicsAPI,  /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_type.as_number,       /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_type.as_sequence,     /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_type.as_mapping,      /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_GraphicsAPI,  /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_type.as_buffer,       /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< GraphicsAPI >",              /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_methods,               /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_getset,                /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_GraphicsAPI,            /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_GraphicsAPI,         /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_GraphicsAPI, /* sq_length */
    (binaryfunc) concat_rdcarray_of_GraphicsAPI,                  /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_GraphicsAPI,                /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_GraphicsAPI,               /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_GraphicsAPI,            /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_GraphicsAPI,              /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_GraphicsAPI,            /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_type};

static SwigPyGetSet rdcarray_of_GPUDevice___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_GPUDevice_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(GPUDevice)>.__dict__", (void *) &rdcarray_of_GPUDevice___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_GPUDevice_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_GPUDevice___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_GPUDevice___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_GPUDevice___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_GPUDevice_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_GPUDevice___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_GPUDevice___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_GPUDevice___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_GPUDevice_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_GPUDevice_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_GPUDevice_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_GPUDevice_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_GPUDevice_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_GPUDevice_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_GPUDevice_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_GPUDevice_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_GPUDevice_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_GPUDevice_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_GPUDevice_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_GPUDevice_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_GPUDevice_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_GPUDevice_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_GPUDevice_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_GPUDevice_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_GPUDevice_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_GPUDevice",        /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_GPUDevice_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_GPUDevice,    /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_GPUDevice_t_type.as_number,         /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_GPUDevice_t_type.as_sequence,       /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_GPUDevice_t_type.as_mapping,        /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_GPUDevice,    /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_GPUDevice_t_type.as_buffer,         /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< GPUDevice >",                /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_GPUDevice_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_GPUDevice_t_methods,                 /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_GPUDevice_t_getset,                  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_GPUDevice,              /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_GPUDevice,           /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_GPUDevice,   /* sq_length */
    (binaryfunc) concat_rdcarray_of_GPUDevice,/* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_GPUDevice,                  /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_GPUDevice,                 /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_GPUDevice,              /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_GPUDevice,                /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_GPUDevice,              /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_GPUDevice_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_GPUDevice_t_type};

static SwigPyGetSet rdcarray_of_ShaderConstantType___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderConstantType)>.__dict__", (void *) &rdcarray_of_ShaderConstantType___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderConstantType___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderConstantType___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderConstantType___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderConstantType_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderConstantType",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderConstantType_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderConstantType,               /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderConstantType,               /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderConstantType >",       /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderConstantType,     /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderConstantType,  /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderConstantType,              /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderConstantType,           /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderConstantType,         /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderConstantType,        /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderConstantType,     /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderConstantType,       /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderConstantType,     /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_type};

static SwigPyGetSet rdcarray_of_ShaderChangeStats___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ShaderChangeStats)>.__dict__", (void *) &rdcarray_of_ShaderChangeStats___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ShaderChangeStats___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ShaderChangeStats___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ShaderChangeStats___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ShaderChangeStats_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ShaderChangeStats",/* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ShaderChangeStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ShaderChangeStats,                /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ShaderChangeStats,                /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ShaderChangeStats >",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ShaderChangeStats,      /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ShaderChangeStats,   /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ShaderChangeStats,               /* sq_length */
    (binaryfunc) concat_rdcarray_of_ShaderChangeStats,            /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ShaderChangeStats,          /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ShaderChangeStats,         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ShaderChangeStats,      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ShaderChangeStats,        /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ShaderChangeStats,      /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_type};

static SwigPyGetSet rdcarray_of_ResourceBindStats___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ResourceBindStats)>.__dict__", (void *) &rdcarray_of_ResourceBindStats___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ResourceBindStats___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ResourceBindStats___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ResourceBindStats___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ResourceBindStats_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ResourceBindStats",/* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ResourceBindStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ResourceBindStats,                /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ResourceBindStats,                /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ResourceBindStats >",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ResourceBindStats,      /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ResourceBindStats,   /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ResourceBindStats,               /* sq_length */
    (binaryfunc) concat_rdcarray_of_ResourceBindStats,            /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ResourceBindStats,          /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ResourceBindStats,         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ResourceBindStats,      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ResourceBindStats,        /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ResourceBindStats,      /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_type};

static SwigPyGetSet rdcarray_of_SamplerBindStats___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(SamplerBindStats)>.__dict__", (void *) &rdcarray_of_SamplerBindStats___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_SamplerBindStats___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_SamplerBindStats___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_SamplerBindStats___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_SamplerBindStats_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_SamplerBindStats", /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_SamplerBindStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_SamplerBindStats,                 /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_SamplerBindStats,                 /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< SamplerBindStats >",         /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_SamplerBindStats,       /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_SamplerBindStats,    /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_SamplerBindStats,                /* sq_length */
    (binaryfunc) concat_rdcarray_of_SamplerBindStats,             /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_SamplerBindStats,           /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_SamplerBindStats,          /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_SamplerBindStats,       /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_SamplerBindStats,         /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_SamplerBindStats,       /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_type};

static SwigPyGetSet rdcarray_of_ConstantBindStats___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(ConstantBindStats)>.__dict__", (void *) &rdcarray_of_ConstantBindStats___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_ConstantBindStats___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_ConstantBindStats___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_ConstantBindStats___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_ConstantBindStats_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_ConstantBindStats",/* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_ConstantBindStats_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_ConstantBindStats,                /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_ConstantBindStats,                /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< ConstantBindStats >",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_ConstantBindStats,      /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_ConstantBindStats,   /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_ConstantBindStats,               /* sq_length */
    (binaryfunc) concat_rdcarray_of_ConstantBindStats,            /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_ConstantBindStats,          /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_ConstantBindStats,         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_ConstantBindStats,      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_ConstantBindStats,        /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_ConstantBindStats,      /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_type};

static SwigPyGetSet rdcarray_of_DescriptorRange___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_DescriptorRange_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(DescriptorRange)>.__dict__", (void *) &rdcarray_of_DescriptorRange___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_DescriptorRange_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_DescriptorRange___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_DescriptorRange___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_DescriptorRange___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_DescriptorRange_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_DescriptorRange___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_DescriptorRange___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_DescriptorRange___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_DescriptorRange_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_DescriptorRange_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_DescriptorRange",  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_DescriptorRange_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_DescriptorRange,                  /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_DescriptorRange_t_type.as_number,   /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_DescriptorRange_t_type.as_sequence, /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_DescriptorRange_t_type.as_mapping,  /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_DescriptorRange,                  /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_DescriptorRange_t_type.as_buffer,   /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< DescriptorRange >",          /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_DescriptorRange_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_DescriptorRange_t_methods,           /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_DescriptorRange_t_getset,            /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_DescriptorRange,        /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_DescriptorRange,     /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_DescriptorRange,                 /* sq_length */
    (binaryfunc) concat_rdcarray_of_DescriptorRange,              /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_DescriptorRange,            /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_DescriptorRange,           /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_DescriptorRange,        /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_DescriptorRange,          /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_DescriptorRange,        /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_DescriptorRange_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_DescriptorRange_t_type};

static SwigPyGetSet rdcarray_of_Descriptor___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_Descriptor_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(Descriptor)>.__dict__", (void *) &rdcarray_of_Descriptor___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_Descriptor_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_Descriptor___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_Descriptor___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_Descriptor___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_Descriptor_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_Descriptor___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_Descriptor___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_Descriptor___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_Descriptor_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_Descriptor_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_Descriptor_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_Descriptor_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_Descriptor_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_Descriptor_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_Descriptor_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_Descriptor_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_Descriptor_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_Descriptor_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_Descriptor_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_Descriptor_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_Descriptor_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_Descriptor_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_Descriptor_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_Descriptor_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_Descriptor_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_Descriptor",       /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_Descriptor_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_Descriptor,   /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_Descriptor_t_type.as_number,        /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_Descriptor_t_type.as_sequence,      /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_Descriptor_t_type.as_mapping,       /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_Descriptor,   /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_Descriptor_t_type.as_buffer,        /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< Descriptor >",               /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_Descriptor_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_Descriptor_t_methods,                /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_Descriptor_t_getset,                 /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_Descriptor,             /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_Descriptor,          /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_Descriptor,  /* sq_length */
    (binaryfunc) concat_rdcarray_of_Descriptor,                   /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_Descriptor,                 /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_Descriptor,                /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_Descriptor,             /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_Descriptor,               /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_Descriptor,             /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_Descriptor_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_Descriptor_t_type};

static SwigPyGetSet rdcarray_of_SamplerDescriptor___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(SamplerDescriptor)>.__dict__", (void *) &rdcarray_of_SamplerDescriptor___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_SamplerDescriptor___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_SamplerDescriptor___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_SamplerDescriptor___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_SamplerDescriptor_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_SamplerDescriptor",/* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_SamplerDescriptor_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_SamplerDescriptor,                /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_SamplerDescriptor,                /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< SamplerDescriptor >",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_SamplerDescriptor,      /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_SamplerDescriptor,   /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_SamplerDescriptor,               /* sq_length */
    (binaryfunc) concat_rdcarray_of_SamplerDescriptor,            /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_SamplerDescriptor,          /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_SamplerDescriptor,         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_SamplerDescriptor,      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_SamplerDescriptor,        /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_SamplerDescriptor,      /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_type};

static SwigPyGetSet rdcarray_of_DescriptorAccess___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(DescriptorAccess)>.__dict__", (void *) &rdcarray_of_DescriptorAccess___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_DescriptorAccess___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_DescriptorAccess___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_DescriptorAccess___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_DescriptorAccess_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_DescriptorAccess", /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_DescriptorAccess_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_DescriptorAccess,                 /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_type.as_number,  /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_type.as_mapping, /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_DescriptorAccess,                 /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_type.as_buffer,  /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< DescriptorAccess >",         /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_methods,          /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_getset,           /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_DescriptorAccess,       /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_DescriptorAccess,    /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_DescriptorAccess,                /* sq_length */
    (binaryfunc) concat_rdcarray_of_DescriptorAccess,             /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_DescriptorAccess,           /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_DescriptorAccess,          /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_DescriptorAccess,       /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_DescriptorAccess,         /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_DescriptorAccess,       /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_type};

static SwigPyGetSet rdcarray_of_DescriptorLogicalLocation___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(DescriptorLogicalLocation)>.__dict__", (void *) &rdcarray_of_DescriptorLogicalLocation___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_DescriptorLogicalLocation___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_DescriptorLogicalLocation___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_DescriptorLogicalLocation___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_DescriptorLogicalLocation_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_DescriptorLogicalLocation",            /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_DescriptorLogicalLocation_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_DescriptorLogicalLocation,        /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_DescriptorLogicalLocation,        /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< DescriptorLogicalLocation >",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_DescriptorLogicalLocation,/* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_DescriptorLogicalLocation,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_DescriptorLogicalLocation,       /* sq_length */
    (binaryfunc) concat_rdcarray_of_DescriptorLogicalLocation,    /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_DescriptorLogicalLocation,  /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_DescriptorLogicalLocation, /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_DescriptorLogicalLocation,/* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_DescriptorLogicalLocation,/* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_DescriptorLogicalLocation,/* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_type};

static SwigPyGetSet rdcarray_of_UsedDescriptor___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(UsedDescriptor)>.__dict__", (void *) &rdcarray_of_UsedDescriptor___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_UsedDescriptor___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_UsedDescriptor___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_UsedDescriptor___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_UsedDescriptor_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_UsedDescriptor",   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_UsedDescriptor_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_UsedDescriptor,                   /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_type.as_number,    /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_type.as_sequence,  /* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_type.as_mapping,   /* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_UsedDescriptor,                   /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_type.as_buffer,    /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "::rdcarray< UsedDescriptor >",           /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_methods,            /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_getset,             /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_UsedDescriptor,         /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_UsedDescriptor,      /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_UsedDescriptor,                  /* sq_length */
    (binaryfunc) concat_rdcarray_of_UsedDescriptor,               /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_UsedDescriptor,             /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_UsedDescriptor,            /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_UsedDescriptor,         /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_UsedDescriptor,           /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_UsedDescriptor,         /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_type};

static SwigPyGetSet rdcarray_of_VKPipe_DynamicOffset___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(VKPipe::DynamicOffset)>.__dict__", (void *) &rdcarray_of_VKPipe_DynamicOffset___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_VKPipe_DynamicOffset___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_VKPipe_DynamicOffset___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_VKPipe_DynamicOffset___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_VKPipe_DynamicOffset_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_VKPipe_DynamicOffset",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_VKPipe_DynamicOffset_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_VKPipe_DynamicOffset,             /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_VKPipe_DynamicOffset,             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< VKPipe::DynamicOffset >",      /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_VKPipe_DynamicOffset,   /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_VKPipe_DynamicOffset,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_VKPipe_DynamicOffset,            /* sq_length */
    (binaryfunc) concat_rdcarray_of_VKPipe_DynamicOffset,         /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_VKPipe_DynamicOffset,       /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_VKPipe_DynamicOffset,      /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_VKPipe_DynamicOffset,   /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_VKPipe_DynamicOffset,     /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_VKPipe_DynamicOffset,   /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_type};

static SwigPyGetSet rdcarray_of_VKPipe_DescriptorSet___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(VKPipe::DescriptorSet)>.__dict__", (void *) &rdcarray_of_VKPipe_DescriptorSet___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_VKPipe_DescriptorSet___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_VKPipe_DescriptorSet___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_VKPipe_DescriptorSet___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorSet_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_VKPipe_DescriptorSet",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_VKPipe_DescriptorSet_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_VKPipe_DescriptorSet,             /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_VKPipe_DescriptorSet,             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< VKPipe::DescriptorSet >",      /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_VKPipe_DescriptorSet,   /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_VKPipe_DescriptorSet,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_VKPipe_DescriptorSet,            /* sq_length */
    (binaryfunc) concat_rdcarray_of_VKPipe_DescriptorSet,         /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_VKPipe_DescriptorSet,       /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_VKPipe_DescriptorSet,      /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_VKPipe_DescriptorSet,   /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_VKPipe_DescriptorSet,     /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_VKPipe_DescriptorSet,   /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_type};

static SwigPyGetSet rdcarray_of_VKPipe_DescriptorBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(VKPipe::DescriptorBuffer)>.__dict__", (void *) &rdcarray_of_VKPipe_DescriptorBuffer___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_VKPipe_DescriptorBuffer___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_VKPipe_DescriptorBuffer___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_VKPipe_DescriptorBuffer___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_VKPipe_DescriptorBuffer_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_VKPipe_DescriptorBuffer",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_VKPipe_DescriptorBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_VKPipe_DescriptorBuffer,          /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_VKPipe_DescriptorBuffer,          /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< VKPipe::DescriptorBuffer >",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_VKPipe_DescriptorBuffer,/* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_VKPipe_DescriptorBuffer,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_VKPipe_DescriptorBuffer,         /* sq_length */
    (binaryfunc) concat_rdcarray_of_VKPipe_DescriptorBuffer,      /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_VKPipe_DescriptorBuffer,    /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_VKPipe_DescriptorBuffer,   /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_VKPipe_DescriptorBuffer,/* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_VKPipe_DescriptorBuffer,  /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_VKPipe_DescriptorBuffer,/* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_type};

static SwigPyGetSet rdcarray_of_VKPipe_ImageData___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(VKPipe::ImageData)>.__dict__", (void *) &rdcarray_of_VKPipe_ImageData___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_VKPipe_ImageData___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_VKPipe_ImageData___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_VKPipe_ImageData___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageData_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_VKPipe_ImageData", /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_VKPipe_ImageData_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_VKPipe_ImageData,                 /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_VKPipe_ImageData,                 /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< VKPipe::ImageData >",          /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_VKPipe_ImageData,       /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_VKPipe_ImageData,    /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_VKPipe_ImageData,                /* sq_length */
    (binaryfunc) concat_rdcarray_of_VKPipe_ImageData,             /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_VKPipe_ImageData,           /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_VKPipe_ImageData,          /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_VKPipe_ImageData,       /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_VKPipe_ImageData,         /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_VKPipe_ImageData,       /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_type};

static SwigPyGetSet rdcarray_of_VKPipe_ImageLayout___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(VKPipe::ImageLayout)>.__dict__", (void *) &rdcarray_of_VKPipe_ImageLayout___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_VKPipe_ImageLayout___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_VKPipe_ImageLayout___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_VKPipe_ImageLayout___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_VKPipe_ImageLayout_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_VKPipe_ImageLayout",                   /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_VKPipe_ImageLayout_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_VKPipe_ImageLayout,               /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_VKPipe_ImageLayout,               /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< VKPipe::ImageLayout >",        /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_methods,       /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_getset,        /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_VKPipe_ImageLayout,     /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_VKPipe_ImageLayout,  /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_VKPipe_ImageLayout,              /* sq_length */
    (binaryfunc) concat_rdcarray_of_VKPipe_ImageLayout,           /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_VKPipe_ImageLayout,         /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_VKPipe_ImageLayout,        /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_VKPipe_ImageLayout,     /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_VKPipe_ImageLayout,       /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_VKPipe_ImageLayout,     /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_type};

static SwigPyGetSet rdcarray_of_VKPipe_RenderArea___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(VKPipe::RenderArea)>.__dict__", (void *) &rdcarray_of_VKPipe_RenderArea___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_VKPipe_RenderArea___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_VKPipe_RenderArea___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_VKPipe_RenderArea___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_VKPipe_RenderArea_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_VKPipe_RenderArea",/* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_VKPipe_RenderArea_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_VKPipe_RenderArea,                /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_VKPipe_RenderArea,                /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< VKPipe::RenderArea >",         /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_methods,        /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_getset,         /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_VKPipe_RenderArea,      /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_VKPipe_RenderArea,   /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_VKPipe_RenderArea,               /* sq_length */
    (binaryfunc) concat_rdcarray_of_VKPipe_RenderArea,            /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_VKPipe_RenderArea,          /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_VKPipe_RenderArea,         /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_VKPipe_RenderArea,      /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_VKPipe_RenderArea,        /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_VKPipe_RenderArea,      /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_type};

static SwigPyGetSet rdcarray_of_VKPipe_XFBBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(VKPipe::XFBBuffer)>.__dict__", (void *) &rdcarray_of_VKPipe_XFBBuffer___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_VKPipe_XFBBuffer___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_VKPipe_XFBBuffer___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_VKPipe_XFBBuffer___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_VKPipe_XFBBuffer_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_VKPipe_XFBBuffer", /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_VKPipe_XFBBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_VKPipe_XFBBuffer,                 /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_VKPipe_XFBBuffer,                 /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< VKPipe::XFBBuffer >",          /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_VKPipe_XFBBuffer,       /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_VKPipe_XFBBuffer,    /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_VKPipe_XFBBuffer,                /* sq_length */
    (binaryfunc) concat_rdcarray_of_VKPipe_XFBBuffer,             /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_VKPipe_XFBBuffer,           /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_VKPipe_XFBBuffer,          /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_VKPipe_XFBBuffer,       /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_VKPipe_XFBBuffer,         /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_VKPipe_XFBBuffer,       /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_type};

static SwigPyGetSet rdcarray_of_VKPipe_VertexBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(VKPipe::VertexBuffer)>.__dict__", (void *) &rdcarray_of_VKPipe_VertexBuffer___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_VKPipe_VertexBuffer___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_VKPipe_VertexBuffer___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_VKPipe_VertexBuffer___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBuffer_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_VKPipe_VertexBuffer",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_VKPipe_VertexBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_VKPipe_VertexBuffer,              /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_VKPipe_VertexBuffer,              /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< VKPipe::VertexBuffer >",       /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_VKPipe_VertexBuffer,    /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_VKPipe_VertexBuffer, /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_VKPipe_VertexBuffer,             /* sq_length */
    (binaryfunc) concat_rdcarray_of_VKPipe_VertexBuffer,          /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_VKPipe_VertexBuffer,        /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_VKPipe_VertexBuffer,       /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_VKPipe_VertexBuffer,    /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_VKPipe_VertexBuffer,      /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_VKPipe_VertexBuffer,    /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_type};

static SwigPyGetSet rdcarray_of_VKPipe_VertexAttribute___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(VKPipe::VertexAttribute)>.__dict__", (void *) &rdcarray_of_VKPipe_VertexAttribute___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_VKPipe_VertexAttribute___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_VKPipe_VertexAttribute___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_VKPipe_VertexAttribute___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexAttribute_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_VKPipe_VertexAttribute",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_VKPipe_VertexAttribute_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_VKPipe_VertexAttribute,           /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_VKPipe_VertexAttribute,           /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< VKPipe::VertexAttribute >",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_VKPipe_VertexAttribute, /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_VKPipe_VertexAttribute,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_VKPipe_VertexAttribute,          /* sq_length */
    (binaryfunc) concat_rdcarray_of_VKPipe_VertexAttribute,       /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_VKPipe_VertexAttribute,     /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_VKPipe_VertexAttribute,    /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_VKPipe_VertexAttribute, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_VKPipe_VertexAttribute,   /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_VKPipe_VertexAttribute, /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_type};

static SwigPyGetSet rdcarray_of_VKPipe_VertexBinding___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(VKPipe::VertexBinding)>.__dict__", (void *) &rdcarray_of_VKPipe_VertexBinding___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_VKPipe_VertexBinding___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_VKPipe_VertexBinding___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_VKPipe_VertexBinding___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_VKPipe_VertexBinding_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_VKPipe_VertexBinding",                 /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_VKPipe_VertexBinding_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_VKPipe_VertexBinding,             /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_VKPipe_VertexBinding,             /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< VKPipe::VertexBinding >",      /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_methods,     /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_getset,      /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_VKPipe_VertexBinding,   /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_VKPipe_VertexBinding,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_VKPipe_VertexBinding,            /* sq_length */
    (binaryfunc) concat_rdcarray_of_VKPipe_VertexBinding,         /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_VKPipe_VertexBinding,       /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_VKPipe_VertexBinding,      /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_VKPipe_VertexBinding,   /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_VKPipe_VertexBinding,     /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_VKPipe_VertexBinding,   /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_type};

static SwigPyGetSet rdcarray_of_VKPipe_ViewportScissor___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(VKPipe::ViewportScissor)>.__dict__", (void *) &rdcarray_of_VKPipe_ViewportScissor___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_VKPipe_ViewportScissor___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_VKPipe_ViewportScissor___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_VKPipe_ViewportScissor___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_VKPipe_ViewportScissor_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_VKPipe_ViewportScissor",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_VKPipe_ViewportScissor_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_VKPipe_ViewportScissor,           /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_VKPipe_ViewportScissor,           /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< VKPipe::ViewportScissor >",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_VKPipe_ViewportScissor, /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_VKPipe_ViewportScissor,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_VKPipe_ViewportScissor,          /* sq_length */
    (binaryfunc) concat_rdcarray_of_VKPipe_ViewportScissor,       /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_VKPipe_ViewportScissor,     /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_VKPipe_ViewportScissor,    /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_VKPipe_ViewportScissor, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_VKPipe_ViewportScissor,   /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_VKPipe_ViewportScissor, /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_type};

static SwigPyGetSet rdcarray_of_D3D11Pipe_Layout___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(D3D11Pipe::Layout)>.__dict__", (void *) &rdcarray_of_D3D11Pipe_Layout___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_D3D11Pipe_Layout___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_D3D11Pipe_Layout___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_D3D11Pipe_Layout___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_Layout_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_D3D11Pipe_Layout", /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_D3D11Pipe_Layout_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_D3D11Pipe_Layout,                 /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_D3D11Pipe_Layout,                 /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< D3D11Pipe::Layout >",          /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_D3D11Pipe_Layout,       /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_D3D11Pipe_Layout,    /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_D3D11Pipe_Layout,                /* sq_length */
    (binaryfunc) concat_rdcarray_of_D3D11Pipe_Layout,             /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_D3D11Pipe_Layout,           /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_D3D11Pipe_Layout,          /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_D3D11Pipe_Layout,       /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_D3D11Pipe_Layout,         /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_D3D11Pipe_Layout,       /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_type};

static SwigPyGetSet rdcarray_of_D3D11Pipe_StreamOutBind___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(D3D11Pipe::StreamOutBind)>.__dict__", (void *) &rdcarray_of_D3D11Pipe_StreamOutBind___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_D3D11Pipe_StreamOutBind___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_D3D11Pipe_StreamOutBind___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_D3D11Pipe_StreamOutBind___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_StreamOutBind_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_D3D11Pipe_StreamOutBind",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_D3D11Pipe_StreamOutBind_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_D3D11Pipe_StreamOutBind,          /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_D3D11Pipe_StreamOutBind,          /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< D3D11Pipe::StreamOutBind >",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_D3D11Pipe_StreamOutBind,/* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_D3D11Pipe_StreamOutBind,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_D3D11Pipe_StreamOutBind,         /* sq_length */
    (binaryfunc) concat_rdcarray_of_D3D11Pipe_StreamOutBind,      /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_D3D11Pipe_StreamOutBind,    /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_D3D11Pipe_StreamOutBind,   /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_D3D11Pipe_StreamOutBind,/* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_D3D11Pipe_StreamOutBind,  /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_D3D11Pipe_StreamOutBind,/* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_type};

static SwigPyGetSet rdcarray_of_D3D11Pipe_VertexBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(D3D11Pipe::VertexBuffer)>.__dict__", (void *) &rdcarray_of_D3D11Pipe_VertexBuffer___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_D3D11Pipe_VertexBuffer___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_D3D11Pipe_VertexBuffer___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_D3D11Pipe_VertexBuffer___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_D3D11Pipe_VertexBuffer_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_D3D11Pipe_VertexBuffer",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_D3D11Pipe_VertexBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_D3D11Pipe_VertexBuffer,           /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_D3D11Pipe_VertexBuffer,           /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< D3D11Pipe::VertexBuffer >",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_D3D11Pipe_VertexBuffer, /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_D3D11Pipe_VertexBuffer,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_D3D11Pipe_VertexBuffer,          /* sq_length */
    (binaryfunc) concat_rdcarray_of_D3D11Pipe_VertexBuffer,       /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_D3D11Pipe_VertexBuffer,     /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_D3D11Pipe_VertexBuffer,    /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_D3D11Pipe_VertexBuffer, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_D3D11Pipe_VertexBuffer,   /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_D3D11Pipe_VertexBuffer, /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_type};

static SwigPyGetSet rdcarray_of_D3D12Pipe_Layout___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(D3D12Pipe::Layout)>.__dict__", (void *) &rdcarray_of_D3D12Pipe_Layout___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_D3D12Pipe_Layout___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_D3D12Pipe_Layout___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_D3D12Pipe_Layout___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_Layout_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_D3D12Pipe_Layout", /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_D3D12Pipe_Layout_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_D3D12Pipe_Layout,                 /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_type.as_number, /* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_D3D12Pipe_Layout,                 /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_type.as_buffer, /* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< D3D12Pipe::Layout >",          /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_methods,         /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_getset,          /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_D3D12Pipe_Layout,       /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_D3D12Pipe_Layout,    /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_D3D12Pipe_Layout,                /* sq_length */
    (binaryfunc) concat_rdcarray_of_D3D12Pipe_Layout,             /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_D3D12Pipe_Layout,           /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_D3D12Pipe_Layout,          /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_D3D12Pipe_Layout,       /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_D3D12Pipe_Layout,         /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_D3D12Pipe_Layout,       /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_type};

static SwigPyGetSet rdcarray_of_D3D12Pipe_ResourceData___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(D3D12Pipe::ResourceData)>.__dict__", (void *) &rdcarray_of_D3D12Pipe_ResourceData___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_D3D12Pipe_ResourceData___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_D3D12Pipe_ResourceData___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_D3D12Pipe_ResourceData___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceData_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_D3D12Pipe_ResourceData",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_D3D12Pipe_ResourceData_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_D3D12Pipe_ResourceData,           /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_D3D12Pipe_ResourceData,           /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< D3D12Pipe::ResourceData >",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_D3D12Pipe_ResourceData, /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_D3D12Pipe_ResourceData,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_D3D12Pipe_ResourceData,          /* sq_length */
    (binaryfunc) concat_rdcarray_of_D3D12Pipe_ResourceData,       /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_D3D12Pipe_ResourceData,     /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_D3D12Pipe_ResourceData,    /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_D3D12Pipe_ResourceData, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_D3D12Pipe_ResourceData,   /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_D3D12Pipe_ResourceData, /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_type};

static SwigPyGetSet rdcarray_of_D3D12Pipe_ResourceState___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(D3D12Pipe::ResourceState)>.__dict__", (void *) &rdcarray_of_D3D12Pipe_ResourceState___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_D3D12Pipe_ResourceState___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_D3D12Pipe_ResourceState___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_D3D12Pipe_ResourceState___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_ResourceState_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_D3D12Pipe_ResourceState",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_D3D12Pipe_ResourceState_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_D3D12Pipe_ResourceState,          /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_D3D12Pipe_ResourceState,          /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< D3D12Pipe::ResourceState >",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_D3D12Pipe_ResourceState,/* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_D3D12Pipe_ResourceState,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_D3D12Pipe_ResourceState,         /* sq_length */
    (binaryfunc) concat_rdcarray_of_D3D12Pipe_ResourceState,      /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_D3D12Pipe_ResourceState,    /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_D3D12Pipe_ResourceState,   /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_D3D12Pipe_ResourceState,/* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_D3D12Pipe_ResourceState,  /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_D3D12Pipe_ResourceState,/* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_type};

static SwigPyGetSet rdcarray_of_D3D12Pipe_StreamOutBind___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(D3D12Pipe::StreamOutBind)>.__dict__", (void *) &rdcarray_of_D3D12Pipe_StreamOutBind___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_D3D12Pipe_StreamOutBind___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_D3D12Pipe_StreamOutBind___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_D3D12Pipe_StreamOutBind___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StreamOutBind_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_D3D12Pipe_StreamOutBind",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_D3D12Pipe_StreamOutBind_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_D3D12Pipe_StreamOutBind,          /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_D3D12Pipe_StreamOutBind,          /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< D3D12Pipe::StreamOutBind >",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_D3D12Pipe_StreamOutBind,/* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_D3D12Pipe_StreamOutBind,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_D3D12Pipe_StreamOutBind,         /* sq_length */
    (binaryfunc) concat_rdcarray_of_D3D12Pipe_StreamOutBind,      /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_D3D12Pipe_StreamOutBind,    /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_D3D12Pipe_StreamOutBind,   /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_D3D12Pipe_StreamOutBind,/* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_D3D12Pipe_StreamOutBind,  /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_D3D12Pipe_StreamOutBind,/* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_type};

static SwigPyGetSet rdcarray_of_D3D12Pipe_VertexBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(D3D12Pipe::VertexBuffer)>.__dict__", (void *) &rdcarray_of_D3D12Pipe_VertexBuffer___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_D3D12Pipe_VertexBuffer___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_D3D12Pipe_VertexBuffer___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_D3D12Pipe_VertexBuffer___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_VertexBuffer_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_D3D12Pipe_VertexBuffer",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_D3D12Pipe_VertexBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_D3D12Pipe_VertexBuffer,           /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_D3D12Pipe_VertexBuffer,           /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< D3D12Pipe::VertexBuffer >",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_D3D12Pipe_VertexBuffer, /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_D3D12Pipe_VertexBuffer,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_D3D12Pipe_VertexBuffer,          /* sq_length */
    (binaryfunc) concat_rdcarray_of_D3D12Pipe_VertexBuffer,       /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_D3D12Pipe_VertexBuffer,     /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_D3D12Pipe_VertexBuffer,    /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_D3D12Pipe_VertexBuffer, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_D3D12Pipe_VertexBuffer,   /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_D3D12Pipe_VertexBuffer, /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_type};

static SwigPyGetSet rdcarray_of_D3D12Pipe_RootTableRange___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(D3D12Pipe::RootTableRange)>.__dict__", (void *) &rdcarray_of_D3D12Pipe_RootTableRange___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_D3D12Pipe_RootTableRange___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_D3D12Pipe_RootTableRange___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_D3D12Pipe_RootTableRange___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootTableRange_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_D3D12Pipe_RootTableRange",             /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_D3D12Pipe_RootTableRange_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_D3D12Pipe_RootTableRange,         /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_D3D12Pipe_RootTableRange,         /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< D3D12Pipe::RootTableRange >",  /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_methods, /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_getset,  /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_D3D12Pipe_RootTableRange,/* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_D3D12Pipe_RootTableRange,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_D3D12Pipe_RootTableRange,        /* sq_length */
    (binaryfunc) concat_rdcarray_of_D3D12Pipe_RootTableRange,     /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_D3D12Pipe_RootTableRange,   /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_D3D12Pipe_RootTableRange,  /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_D3D12Pipe_RootTableRange,/* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_D3D12Pipe_RootTableRange, /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_D3D12Pipe_RootTableRange,/* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_type};

static SwigPyGetSet rdcarray_of_D3D12Pipe_RootParam___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(D3D12Pipe::RootParam)>.__dict__", (void *) &rdcarray_of_D3D12Pipe_RootParam___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_D3D12Pipe_RootParam___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_D3D12Pipe_RootParam___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_D3D12Pipe_RootParam___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_RootParam_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_D3D12Pipe_RootParam",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_D3D12Pipe_RootParam_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_D3D12Pipe_RootParam,              /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_D3D12Pipe_RootParam,              /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< D3D12Pipe::RootParam >",       /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_D3D12Pipe_RootParam,    /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_D3D12Pipe_RootParam, /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_D3D12Pipe_RootParam,             /* sq_length */
    (binaryfunc) concat_rdcarray_of_D3D12Pipe_RootParam,          /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_D3D12Pipe_RootParam,        /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_D3D12Pipe_RootParam,       /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_D3D12Pipe_RootParam,    /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_D3D12Pipe_RootParam,      /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_D3D12Pipe_RootParam,    /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_type};

static SwigPyGetSet rdcarray_of_D3D12Pipe_StaticSampler___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(D3D12Pipe::StaticSampler)>.__dict__", (void *) &rdcarray_of_D3D12Pipe_StaticSampler___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_D3D12Pipe_StaticSampler___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_D3D12Pipe_StaticSampler___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_D3D12Pipe_StaticSampler___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_D3D12Pipe_StaticSampler_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_D3D12Pipe_StaticSampler",              /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_D3D12Pipe_StaticSampler_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_D3D12Pipe_StaticSampler,          /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_D3D12Pipe_StaticSampler,          /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< D3D12Pipe::StaticSampler >",   /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_methods,  /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_getset,   /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_D3D12Pipe_StaticSampler,/* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_D3D12Pipe_StaticSampler,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_D3D12Pipe_StaticSampler,         /* sq_length */
    (binaryfunc) concat_rdcarray_of_D3D12Pipe_StaticSampler,      /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_D3D12Pipe_StaticSampler,    /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_D3D12Pipe_StaticSampler,   /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_D3D12Pipe_StaticSampler,/* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_D3D12Pipe_StaticSampler,  /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_D3D12Pipe_StaticSampler,/* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_type};

static SwigPyGetSet rdcarray_of_GLPipe_VertexBuffer___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(GLPipe::VertexBuffer)>.__dict__", (void *) &rdcarray_of_GLPipe_VertexBuffer___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_GLPipe_VertexBuffer___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_GLPipe_VertexBuffer___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_GLPipe_VertexBuffer___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexBuffer_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_GLPipe_VertexBuffer",                  /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_GLPipe_VertexBuffer_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_GLPipe_VertexBuffer,              /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_GLPipe_VertexBuffer,              /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< GLPipe::VertexBuffer >",       /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_methods,      /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_getset,       /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_GLPipe_VertexBuffer,    /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_GLPipe_VertexBuffer, /* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_GLPipe_VertexBuffer,             /* sq_length */
    (binaryfunc) concat_rdcarray_of_GLPipe_VertexBuffer,          /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_GLPipe_VertexBuffer,        /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_GLPipe_VertexBuffer,       /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_GLPipe_VertexBuffer,    /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_GLPipe_VertexBuffer,      /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_GLPipe_VertexBuffer,    /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_type};

static SwigPyGetSet rdcarray_of_GLPipe_VertexAttribute___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(GLPipe::VertexAttribute)>.__dict__", (void *) &rdcarray_of_GLPipe_VertexAttribute___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_GLPipe_VertexAttribute___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_GLPipe_VertexAttribute___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_GLPipe_VertexAttribute___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_GLPipe_VertexAttribute_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_GLPipe_VertexAttribute",               /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_GLPipe_VertexAttribute_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_GLPipe_VertexAttribute,           /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_GLPipe_VertexAttribute,           /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< GLPipe::VertexAttribute >",    /* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_methods,   /* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_getset,    /* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_GLPipe_VertexAttribute, /* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_GLPipe_VertexAttribute,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_GLPipe_VertexAttribute,          /* sq_length */
    (binaryfunc) concat_rdcarray_of_GLPipe_VertexAttribute,       /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_GLPipe_VertexAttribute,     /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_GLPipe_VertexAttribute,    /* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_GLPipe_VertexAttribute, /* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_GLPipe_VertexAttribute,   /* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_GLPipe_VertexAttribute, /* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_type};

static SwigPyGetSet rdcarray_of_GLPipe_TextureCompleteness___dict___getset = { SwigPyObject_get___dict__, 0 };
SWIGINTERN PyGetSetDef SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_getset[] = {
    { (char *) "__dict__", (getter) SwigPyBuiltin_FunpackGetterClosure, (setter) 0, (char *)"rdcarray<(GLPipe::TextureCompleteness)>.__dict__", (void *) &rdcarray_of_GLPipe_TextureCompleteness___dict___getset }
,
    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};

SWIGINTERN PyObject *
SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_richcompare(PyObject *self, PyObject *other, int op) {
  PyObject *result = NULL;
  switch (op) {
    case Py_EQ : result = _wrap_rdcarray_of_GLPipe_TextureCompleteness___eq__(self, other); break;
    case Py_NE : result = _wrap_rdcarray_of_GLPipe_TextureCompleteness___ne__(self, other); break;
    case Py_LT : result = _wrap_rdcarray_of_GLPipe_TextureCompleteness___lt__(self, other); break;
    default : break;
  }
  if (!result) {
    if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
      result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
    } else {
      result = Py_NotImplemented;
      Py_INCREF(result);
    }
  }
  return result;
}

SWIGINTERN PyMethodDef SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_methods[] = {
  { "__eq__", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness___eq__, METH_O, (char *) "__eq__(o)" },
  { "__ne__", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness___ne__, METH_O, (char *) "__ne__(o)" },
  { "__lt__", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness___lt__, METH_O, (char *) "__lt__(o)" },
  { "resize_for_index", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_resize_for_index, METH_O, (char *) "resize_for_index(s)" },
  { "fill", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_fill, METH_VARARGS, (char *) "fill(count, el)" },
  { "pop_back", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_pop_back, METH_NOARGS, (char *) "pop_back()" },
  { "removeIf", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_removeIf, METH_O, (char *) "removeIf(predicate)" },
  { "removeOneIf", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_removeOneIf, METH_O, (char *) "removeOneIf(predicate)" },
  { "append", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_append, METH_O, (char *) "append(value)" },
  { "clear", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_clear, METH_NOARGS, (char *) "clear()" },
  { "insert", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_insert, METH_VARARGS, (char *) "insert(index, value)" },
  { "pop", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_pop, METH_VARARGS|METH_KEYWORDS, (char *) "pop(index=None)" },
  { "sort", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_sort, METH_VARARGS|METH_KEYWORDS, (char *) "sort(key=None, reverse=False)" },
  { "copy", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_copy, METH_NOARGS, (char *) "copy()" },
  { "reverse", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_reverse, METH_NOARGS, (char *) "reverse()" },
  { "index", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_index, METH_VARARGS|METH_KEYWORDS, (char *) "index(item, start=None, end=None)" },
  { "count", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_count, METH_O, (char *) "count(item)" },
  { "extend", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_extend, METH_O, (char *) "extend(items)" },
  { "remove", (PyCFunction) _wrap_rdcarray_of_GLPipe_TextureCompleteness_remove, METH_O, (char *) "remove(item)" },
  { NULL, NULL, 0, NULL } /* Sentinel */
};

static PyHeapTypeObject SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_type = {
  {
#if PY_VERSION_HEX >= 0x03000000
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,                                        /* ob_size */
#endif
    "renderdoc.rdcarray_of_GLPipe_TextureCompleteness",           /* tp_name */
    sizeof(SwigPyObject),                     /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor) (destructor) _wrap_delete_rdcarray_of_GLPipe_TextureCompleteness_destructor_closure,/* tp_dealloc */
    (printfunc) 0,                            /* tp_print */
    (getattrfunc) 0,                          /* tp_getattr */
    (setattrfunc) 0,                          /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
    0,                                        /* tp_compare */
#else
    (cmpfunc) 0,                              /* tp_compare */
#endif
    (reprfunc) repr_rdcarray_of_GLPipe_TextureCompleteness,       /* tp_repr */
    &SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_type.as_number,/* tp_as_number */
    &SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_type.as_sequence,/* tp_as_sequence */
    &SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_type.as_mapping,/* tp_as_mapping */
    (hashfunc) SwigPyObject_hash,             /* tp_hash */
    (ternaryfunc) 0,                          /* tp_call */
    (reprfunc) repr_rdcarray_of_GLPipe_TextureCompleteness,       /* tp_str */
    (getattrofunc) 0,                         /* tp_getattro */
    (setattrofunc) 0,                         /* tp_setattro */
    &SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_type.as_buffer,/* tp_as_buffer */
#if PY_VERSION_HEX >= 0x03000000
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
#else
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
#endif
    "rdcarray< GLPipe::TextureCompleteness >",/* tp_doc */
    (traverseproc) 0,                         /* tp_traverse */
    (inquiry) 0,                              /* tp_clear */
    (richcmpfunc) SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_richcompare,/* tp_richcompare */
    0,                                        /* tp_weaklistoffset */
    (getiterfunc) 0,                          /* tp_iter */
    (iternextfunc) 0,                         /* tp_iternext */
    SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_methods,/* tp_methods */
    0,                                        /* tp_members */
    SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_getset,/* tp_getset */
    0,                                        /* tp_base */
    0,                                        /* tp_dict */
    (descrgetfunc) 0,                         /* tp_descr_get */
    (descrsetfunc) 0,                         /* tp_descr_set */
    (Py_ssize_t) offsetof(SwigPyObject, dict),/* tp_dictoffset */
    (initproc) SwigPyBuiltin_BadInit,         /* tp_init */
    (allocfunc) 0,                            /* tp_alloc */
    (newfunc) 0,                              /* tp_new */
    (freefunc) 0,                             /* tp_free */
    (inquiry) 0,                              /* tp_is_gc */
    (PyObject *) 0,                           /* tp_bases */
    (PyObject *) 0,                           /* tp_mro */
    (PyObject *) 0,                           /* tp_cache */
    (PyObject *) 0,                           /* tp_subclasses */
    (PyObject *) 0,                           /* tp_weaklist */
    (destructor) 0,                           /* tp_del */
#if PY_VERSION_HEX >= 0x02060000
    (int) 0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
    (destructor) 0,                           /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
    (Py_ssize_t) 0,                           /* tp_allocs */
    (Py_ssize_t) 0,                           /* tp_frees */
    (Py_ssize_t) 0,                           /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
    0,                                        /* tp_prev */
#endif
    0,                                        /* tp_next */
#endif
  },
#if PY_VERSION_HEX >= 0x03050000
  {
    (unaryfunc) 0,                            /* am_await */
    (unaryfunc) 0,                            /* am_aiter */
    (unaryfunc) 0,                            /* am_anext */
  },
#endif
  {
    (binaryfunc) 0,                           /* nb_add */
    (binaryfunc) 0,                           /* nb_subtract */
    (binaryfunc) 0,                           /* nb_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_divide */
#endif
    (binaryfunc) 0,                           /* nb_remainder */
    (binaryfunc) 0,                           /* nb_divmod */
    (ternaryfunc) 0,                          /* nb_power */
    (unaryfunc) 0,                            /* nb_negative */
    (unaryfunc) 0,                            /* nb_positive */
    (unaryfunc) 0,                            /* nb_absolute */
    (inquiry) 0,                              /* nb_nonzero */
    (unaryfunc) 0,                            /* nb_invert */
    (binaryfunc) 0,                           /* nb_lshift */
    (binaryfunc) 0,                           /* nb_rshift */
    (binaryfunc) 0,                           /* nb_and */
    (binaryfunc) 0,                           /* nb_xor */
    (binaryfunc) 0,                           /* nb_or */
#if PY_VERSION_HEX < 0x03000000
    (coercion) 0,                             /* nb_coerce */
#endif
    (unaryfunc) 0,                            /* nb_int */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* nb_reserved */
#else
    (unaryfunc) 0,                            /* nb_long */
#endif
    (unaryfunc) 0,                            /* nb_float */
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc) 0,                            /* nb_oct */
    (unaryfunc) 0,                            /* nb_hex */
#endif
    (binaryfunc) 0,                           /* nb_inplace_add */
    (binaryfunc) 0,                           /* nb_inplace_subtract */
    (binaryfunc) 0,                           /* nb_inplace_multiply */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc) 0,                           /* nb_inplace_divide */
#endif
    (binaryfunc) 0,                           /* nb_inplace_remainder */
    (ternaryfunc) 0,                          /* nb_inplace_power */
    (binaryfunc) 0,                           /* nb_inplace_lshift */
    (binaryfunc) 0,                           /* nb_inplace_rshift */
    (binaryfunc) 0,                           /* nb_inplace_and */
    (binaryfunc) 0,                           /* nb_inplace_xor */
    (binaryfunc) 0,                           /* nb_inplace_or */
    (binaryfunc) 0,                           /* nb_floor_divide */
    (binaryfunc) 0,                           /* nb_true_divide */
    (binaryfunc) 0,                           /* nb_inplace_floor_divide */
    (binaryfunc) 0,                           /* nb_inplace_true_divide */
#if PY_VERSION_HEX >= 0x02050000
    (unaryfunc) 0,                            /* nb_index */
#endif
#if PY_VERSION_HEX >= 0x03050000
    (binaryfunc) 0,                           /* nb_matrix_multiply */
    (binaryfunc) 0,                           /* nb_inplace_matrix_multiply */
#endif
  },
  {
    (lenfunc) 0,                              /* mp_length */
    (binaryfunc) getsubscript_rdcarray_of_GLPipe_TextureCompleteness,/* mp_subscript */
    (objobjargproc) setsubscript_rdcarray_of_GLPipe_TextureCompleteness,/* mp_ass_subscript */
  },
  {
    (lenfunc) length_rdcarray_of_GLPipe_TextureCompleteness,      /* sq_length */
    (binaryfunc) concat_rdcarray_of_GLPipe_TextureCompleteness,   /* sq_concat */
    (ssizeargfunc) repeat_rdcarray_of_GLPipe_TextureCompleteness, /* sq_repeat */
    (ssizeargfunc) getitem_rdcarray_of_GLPipe_TextureCompleteness,/* sq_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_slice */
#else
    (ssizessizeargfunc) 0,                    /* sq_slice */
#endif
    (ssizeobjargproc) setitem_rdcarray_of_GLPipe_TextureCompleteness,/* sq_ass_item */
#if PY_VERSION_HEX >= 0x03000000
    (void *) 0,                               /* was_sq_ass_slice */
#else
    (ssizessizeobjargproc) 0,                 /* sq_ass_slice */
#endif
    (objobjproc) 0,                           /* sq_contains */
    (binaryfunc) selfconcat_rdcarray_of_GLPipe_TextureCompleteness,/* sq_inplace_concat */
    (ssizeargfunc) selfrepeat_rdcarray_of_GLPipe_TextureCompleteness,/* sq_inplace_repeat */
  },
  {
#if PY_VERSION_HEX < 0x03000000
    (readbufferproc) 0,                       /* bf_getreadbuffer */
    (writebufferproc) 0,                      /* bf_getwritebuffer */
    (segcountproc) 0,                         /* bf_getsegcount */
    (charbufferproc) 0,                       /* bf_getcharbuffer */
#endif
#if PY_VERSION_HEX >= 0x02060000
    (getbufferproc) 0,                        /* bf_getbuffer */
    (releasebufferproc) 0,                    /* bf_releasebuffer */
#endif
  },
    (PyObject *) 0,                           /* ht_name */
    (PyObject *) 0,                           /* ht_slots */
#if PY_VERSION_HEX >= 0x03030000
    (PyObject *) 0,                           /* ht_qualname */
    0,                                        /* ht_cached_keys */
#endif
};

SWIGINTERN SwigPyClientData SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_type};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_ICaptureFileTo_p_ICaptureAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ICaptureAccess *)  ((ICaptureFile *) x));
}
static void *_p_IRemoteServerTo_p_ICaptureAccess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ICaptureAccess *)  ((IRemoteServer *) x));
}
static void *_p_SDChunkTo_p_SDObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SDObject *)  ((SDChunk *) x));
}
static swig_type_info _swigt__p_ANativeWindow = {"_p_ANativeWindow", "ANativeWindow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_APIEvent = {"_p_APIEvent", "APIEvent *", 0, 0, (void*)&SwigPyBuiltin__APIEvent_clientdata, 0};
static swig_type_info _swigt__p_APIProperties = {"_p_APIProperties", "APIProperties *", 0, 0, (void*)&SwigPyBuiltin__APIProperties_clientdata, 0};
static swig_type_info _swigt__p_APIUseData = {"_p_APIUseData", "APIUseData *", 0, 0, (void*)&SwigPyBuiltin__APIUseData_clientdata, 0};
static swig_type_info _swigt__p_ActionDescription = {"_p_ActionDescription", "ActionDescription *", 0, 0, (void*)&SwigPyBuiltin__ActionDescription_clientdata, 0};
static swig_type_info _swigt__p_ActionFlags = {"_p_ActionFlags", "enum ActionFlags *|ActionFlags *", 0, 0, (void*)&SwigPyBuiltin__ActionFlags_clientdata, 0};
static swig_type_info _swigt__p_AddressMode = {"_p_AddressMode", "enum AddressMode *|AddressMode *", 0, 0, (void*)&SwigPyBuiltin__AddressMode_clientdata, 0};
static swig_type_info _swigt__p_AlphaMapping = {"_p_AlphaMapping", "enum AlphaMapping *|AlphaMapping *", 0, 0, (void*)&SwigPyBuiltin__AlphaMapping_clientdata, 0};
static swig_type_info _swigt__p_AndroidFlags = {"_p_AndroidFlags", "enum AndroidFlags *|AndroidFlags *", 0, 0, (void*)&SwigPyBuiltin__AndroidFlags_clientdata, 0};
static swig_type_info _swigt__p_AxisMapping = {"_p_AxisMapping", "AxisMapping *", 0, 0, (void*)&SwigPyBuiltin__AxisMapping_clientdata, 0};
static swig_type_info _swigt__p_BindType = {"_p_BindType", "enum BindType *|BindType *", 0, 0, (void*)&SwigPyBuiltin__BindType_clientdata, 0};
static swig_type_info _swigt__p_BlendEquation = {"_p_BlendEquation", "BlendEquation *", 0, 0, (void*)&SwigPyBuiltin__BlendEquation_clientdata, 0};
static swig_type_info _swigt__p_BlendMultiplier = {"_p_BlendMultiplier", "enum BlendMultiplier *|BlendMultiplier *", 0, 0, (void*)&SwigPyBuiltin__BlendMultiplier_clientdata, 0};
static swig_type_info _swigt__p_BlendOperation = {"_p_BlendOperation", "enum BlendOperation *|BlendOperation *", 0, 0, (void*)&SwigPyBuiltin__BlendOperation_clientdata, 0};
static swig_type_info _swigt__p_BlendStats = {"_p_BlendStats", "BlendStats *", 0, 0, (void*)&SwigPyBuiltin__BlendStats_clientdata, 0};
static swig_type_info _swigt__p_BoundVBuffer = {"_p_BoundVBuffer", "BoundVBuffer *", 0, 0, (void*)&SwigPyBuiltin__BoundVBuffer_clientdata, 0};
static swig_type_info _swigt__p_BucketRecordType = {"_p_BucketRecordType", "enum BucketRecordType *|BucketRecordType *", 0, 0, (void*)&SwigPyBuiltin__BucketRecordType_clientdata, 0};
static swig_type_info _swigt__p_BufferCategory = {"_p_BufferCategory", "enum BufferCategory *|BufferCategory *", 0, 0, (void*)&SwigPyBuiltin__BufferCategory_clientdata, 0};
static swig_type_info _swigt__p_BufferDescription = {"_p_BufferDescription", "BufferDescription *", 0, 0, (void*)&SwigPyBuiltin__BufferDescription_clientdata, 0};
static swig_type_info _swigt__p_BusyData = {"_p_BusyData", "BusyData *", 0, 0, (void*)&SwigPyBuiltin__BusyData_clientdata, 0};
static swig_type_info _swigt__p_CameraType = {"_p_CameraType", "enum CameraType *|CameraType *", 0, 0, (void*)&SwigPyBuiltin__CameraType_clientdata, 0};
static swig_type_info _swigt__p_CaptureFileFormat = {"_p_CaptureFileFormat", "CaptureFileFormat *", 0, 0, (void*)&SwigPyBuiltin__CaptureFileFormat_clientdata, 0};
static swig_type_info _swigt__p_CaptureOptions = {"_p_CaptureOptions", "struct CaptureOptions *|CaptureOptions *", 0, 0, (void*)&SwigPyBuiltin__CaptureOptions_clientdata, 0};
static swig_type_info _swigt__p_ChromaSampleLocation = {"_p_ChromaSampleLocation", "enum ChromaSampleLocation *|ChromaSampleLocation *", 0, 0, (void*)&SwigPyBuiltin__ChromaSampleLocation_clientdata, 0};
static swig_type_info _swigt__p_ColorBlend = {"_p_ColorBlend", "ColorBlend *", 0, 0, (void*)&SwigPyBuiltin__ColorBlend_clientdata, 0};
static swig_type_info _swigt__p_CompType = {"_p_CompType", "enum CompType *|CompType *", 0, 0, (void*)&SwigPyBuiltin__CompType_clientdata, 0};
static swig_type_info _swigt__p_CompareFunction = {"_p_CompareFunction", "enum CompareFunction *|CompareFunction *", 0, 0, (void*)&SwigPyBuiltin__CompareFunction_clientdata, 0};
static swig_type_info _swigt__p_ConservativeRaster = {"_p_ConservativeRaster", "enum ConservativeRaster *|ConservativeRaster *", 0, 0, (void*)&SwigPyBuiltin__ConservativeRaster_clientdata, 0};
static swig_type_info _swigt__p_ConstantBindStats = {"_p_ConstantBindStats", "ConstantBindStats *", 0, 0, (void*)&SwigPyBuiltin__ConstantBindStats_clientdata, 0};
static swig_type_info _swigt__p_ConstantBlock = {"_p_ConstantBlock", "ConstantBlock *", 0, 0, (void*)&SwigPyBuiltin__ConstantBlock_clientdata, 0};
static swig_type_info _swigt__p_CounterDescription = {"_p_CounterDescription", "CounterDescription *", 0, 0, (void*)&SwigPyBuiltin__CounterDescription_clientdata, 0};
static swig_type_info _swigt__p_CounterResult = {"_p_CounterResult", "CounterResult *", 0, 0, (void*)&SwigPyBuiltin__CounterResult_clientdata, 0};
static swig_type_info _swigt__p_CounterUnit = {"_p_CounterUnit", "enum CounterUnit *|CounterUnit *", 0, 0, (void*)&SwigPyBuiltin__CounterUnit_clientdata, 0};
static swig_type_info _swigt__p_CounterValue = {"_p_CounterValue", "CounterValue *", 0, 0, (void*)&SwigPyBuiltin__CounterValue_clientdata, 0};
static swig_type_info _swigt__p_CullMode = {"_p_CullMode", "enum CullMode *|CullMode *", 0, 0, (void*)&SwigPyBuiltin__CullMode_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__BlendState = {"_p_D3D11Pipe__BlendState", "D3D11Pipe::BlendState *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__BlendState_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__DepthStencilState = {"_p_D3D11Pipe__DepthStencilState", "D3D11Pipe::DepthStencilState *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__DepthStencilState_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__IndexBuffer = {"_p_D3D11Pipe__IndexBuffer", "D3D11Pipe::IndexBuffer *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__IndexBuffer_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__InputAssembly = {"_p_D3D11Pipe__InputAssembly", "D3D11Pipe::InputAssembly *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__InputAssembly_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__Layout = {"_p_D3D11Pipe__Layout", "D3D11Pipe::Layout *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__Layout_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__OutputMerger = {"_p_D3D11Pipe__OutputMerger", "D3D11Pipe::OutputMerger *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__OutputMerger_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__Predication = {"_p_D3D11Pipe__Predication", "D3D11Pipe::Predication *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__Predication_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__Rasterizer = {"_p_D3D11Pipe__Rasterizer", "D3D11Pipe::Rasterizer *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__Rasterizer_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__RasterizerState = {"_p_D3D11Pipe__RasterizerState", "D3D11Pipe::RasterizerState *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__RasterizerState_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__Shader = {"_p_D3D11Pipe__Shader", "D3D11Pipe::Shader *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__Shader_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__State = {"_p_D3D11Pipe__State", "D3D11Pipe::State *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__State_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__StreamOut = {"_p_D3D11Pipe__StreamOut", "D3D11Pipe::StreamOut *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__StreamOut_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__StreamOutBind = {"_p_D3D11Pipe__StreamOutBind", "D3D11Pipe::StreamOutBind *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__StreamOutBind_clientdata, 0};
static swig_type_info _swigt__p_D3D11Pipe__VertexBuffer = {"_p_D3D11Pipe__VertexBuffer", "D3D11Pipe::VertexBuffer *", 0, 0, (void*)&SwigPyBuiltin__D3D11Pipe__VertexBuffer_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__BlendState = {"_p_D3D12Pipe__BlendState", "D3D12Pipe::BlendState *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__BlendState_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__DepthStencilState = {"_p_D3D12Pipe__DepthStencilState", "D3D12Pipe::DepthStencilState *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__DepthStencilState_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__IndexBuffer = {"_p_D3D12Pipe__IndexBuffer", "D3D12Pipe::IndexBuffer *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__IndexBuffer_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__InputAssembly = {"_p_D3D12Pipe__InputAssembly", "D3D12Pipe::InputAssembly *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__InputAssembly_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__Layout = {"_p_D3D12Pipe__Layout", "D3D12Pipe::Layout *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__Layout_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__OM = {"_p_D3D12Pipe__OM", "D3D12Pipe::OM *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__OM_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__Predication = {"_p_D3D12Pipe__Predication", "D3D12Pipe::Predication *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__Predication_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__Rasterizer = {"_p_D3D12Pipe__Rasterizer", "D3D12Pipe::Rasterizer *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__Rasterizer_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__RasterizerState = {"_p_D3D12Pipe__RasterizerState", "D3D12Pipe::RasterizerState *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__RasterizerState_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__ResourceData = {"_p_D3D12Pipe__ResourceData", "D3D12Pipe::ResourceData *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__ResourceData_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__ResourceState = {"_p_D3D12Pipe__ResourceState", "D3D12Pipe::ResourceState *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__ResourceState_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__RootParam = {"_p_D3D12Pipe__RootParam", "D3D12Pipe::RootParam *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__RootParam_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__RootSignature = {"_p_D3D12Pipe__RootSignature", "D3D12Pipe::RootSignature *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__RootSignature_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__RootTableRange = {"_p_D3D12Pipe__RootTableRange", "D3D12Pipe::RootTableRange *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__RootTableRange_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__Shader = {"_p_D3D12Pipe__Shader", "D3D12Pipe::Shader *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__Shader_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__State = {"_p_D3D12Pipe__State", "D3D12Pipe::State *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__State_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__StaticSampler = {"_p_D3D12Pipe__StaticSampler", "D3D12Pipe::StaticSampler *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__StaticSampler_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__StreamOut = {"_p_D3D12Pipe__StreamOut", "D3D12Pipe::StreamOut *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__StreamOut_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__StreamOutBind = {"_p_D3D12Pipe__StreamOutBind", "D3D12Pipe::StreamOutBind *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__StreamOutBind_clientdata, 0};
static swig_type_info _swigt__p_D3D12Pipe__VertexBuffer = {"_p_D3D12Pipe__VertexBuffer", "D3D12Pipe::VertexBuffer *", 0, 0, (void*)&SwigPyBuiltin__D3D12Pipe__VertexBuffer_clientdata, 0};
static swig_type_info _swigt__p_DebugMessage = {"_p_DebugMessage", "DebugMessage *", 0, 0, (void*)&SwigPyBuiltin__DebugMessage_clientdata, 0};
static swig_type_info _swigt__p_DebugOverlay = {"_p_DebugOverlay", "enum DebugOverlay *|DebugOverlay *", 0, 0, (void*)&SwigPyBuiltin__DebugOverlay_clientdata, 0};
static swig_type_info _swigt__p_DebugPixelInputs = {"_p_DebugPixelInputs", "DebugPixelInputs *", 0, 0, (void*)&SwigPyBuiltin__DebugPixelInputs_clientdata, 0};
static swig_type_info _swigt__p_DebugVariableReference = {"_p_DebugVariableReference", "DebugVariableReference *", 0, 0, (void*)&SwigPyBuiltin__DebugVariableReference_clientdata, 0};
static swig_type_info _swigt__p_DebugVariableType = {"_p_DebugVariableType", "enum DebugVariableType *|DebugVariableType *", 0, 0, (void*)&SwigPyBuiltin__DebugVariableType_clientdata, 0};
static swig_type_info _swigt__p_DepthStencilStats = {"_p_DepthStencilStats", "DepthStencilStats *", 0, 0, (void*)&SwigPyBuiltin__DepthStencilStats_clientdata, 0};
static swig_type_info _swigt__p_DepthTestState = {"_p_DepthTestState", "DepthTestState *", 0, 0, (void*)&SwigPyBuiltin__DepthTestState_clientdata, 0};
static swig_type_info _swigt__p_Descriptor = {"_p_Descriptor", "Descriptor *", 0, 0, (void*)&SwigPyBuiltin__Descriptor_clientdata, 0};
static swig_type_info _swigt__p_DescriptorAccess = {"_p_DescriptorAccess", "DescriptorAccess *", 0, 0, (void*)&SwigPyBuiltin__DescriptorAccess_clientdata, 0};
static swig_type_info _swigt__p_DescriptorCategory = {"_p_DescriptorCategory", "enum DescriptorCategory *|DescriptorCategory *", 0, 0, (void*)&SwigPyBuiltin__DescriptorCategory_clientdata, 0};
static swig_type_info _swigt__p_DescriptorFlags = {"_p_DescriptorFlags", "enum DescriptorFlags *|DescriptorFlags *", 0, 0, (void*)&SwigPyBuiltin__DescriptorFlags_clientdata, 0};
static swig_type_info _swigt__p_DescriptorLogicalLocation = {"_p_DescriptorLogicalLocation", "DescriptorLogicalLocation *", 0, 0, (void*)&SwigPyBuiltin__DescriptorLogicalLocation_clientdata, 0};
static swig_type_info _swigt__p_DescriptorRange = {"_p_DescriptorRange", "DescriptorRange *", 0, 0, (void*)&SwigPyBuiltin__DescriptorRange_clientdata, 0};
static swig_type_info _swigt__p_DescriptorStoreDescription = {"_p_DescriptorStoreDescription", "DescriptorStoreDescription *", 0, 0, (void*)&SwigPyBuiltin__DescriptorStoreDescription_clientdata, 0};
static swig_type_info _swigt__p_DescriptorType = {"_p_DescriptorType", "enum DescriptorType *|DescriptorType *", 0, 0, (void*)&SwigPyBuiltin__DescriptorType_clientdata, 0};
static swig_type_info _swigt__p_DispatchStats = {"_p_DispatchStats", "DispatchStats *", 0, 0, (void*)&SwigPyBuiltin__DispatchStats_clientdata, 0};
static swig_type_info _swigt__p_DrawcallStats = {"_p_DrawcallStats", "DrawcallStats *", 0, 0, (void*)&SwigPyBuiltin__DrawcallStats_clientdata, 0};
static swig_type_info _swigt__p_DriverInformation = {"_p_DriverInformation", "DriverInformation *", 0, 0, (void*)&SwigPyBuiltin__DriverInformation_clientdata, 0};
static swig_type_info _swigt__p_EnvMod = {"_p_EnvMod", "enum EnvMod *|EnvMod *", 0, 0, (void*)&SwigPyBuiltin__EnvMod_clientdata, 0};
static swig_type_info _swigt__p_EnvSep = {"_p_EnvSep", "enum EnvSep *|EnvSep *", 0, 0, (void*)&SwigPyBuiltin__EnvSep_clientdata, 0};
static swig_type_info _swigt__p_EnvironmentModification = {"_p_EnvironmentModification", "EnvironmentModification *", 0, 0, (void*)&SwigPyBuiltin__EnvironmentModification_clientdata, 0};
static swig_type_info _swigt__p_EventUsage = {"_p_EventUsage", "EventUsage *", 0, 0, (void*)&SwigPyBuiltin__EventUsage_clientdata, 0};
static swig_type_info _swigt__p_ExecuteResult = {"_p_ExecuteResult", "ExecuteResult *", 0, 0, (void*)&SwigPyBuiltin__ExecuteResult_clientdata, 0};
static swig_type_info _swigt__p_FileType = {"_p_FileType", "enum FileType *|FileType *", 0, 0, (void*)&SwigPyBuiltin__FileType_clientdata, 0};
static swig_type_info _swigt__p_FillMode = {"_p_FillMode", "enum FillMode *|FillMode *", 0, 0, (void*)&SwigPyBuiltin__FillMode_clientdata, 0};
static swig_type_info _swigt__p_FilterFunction = {"_p_FilterFunction", "enum FilterFunction *|FilterFunction *", 0, 0, (void*)&SwigPyBuiltin__FilterFunction_clientdata, 0};
static swig_type_info _swigt__p_FilterMode = {"_p_FilterMode", "enum FilterMode *|FilterMode *", 0, 0, (void*)&SwigPyBuiltin__FilterMode_clientdata, 0};
static swig_type_info _swigt__p_FloatVector = {"_p_FloatVector", "FloatVector *", 0, 0, (void*)&SwigPyBuiltin__FloatVector_clientdata, 0};
static swig_type_info _swigt__p_FrameDescription = {"_p_FrameDescription", "FrameDescription *", 0, 0, (void*)&SwigPyBuiltin__FrameDescription_clientdata, 0};
static swig_type_info _swigt__p_FrameStatistics = {"_p_FrameStatistics", "FrameStatistics *", 0, 0, (void*)&SwigPyBuiltin__FrameStatistics_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__BlendState = {"_p_GLPipe__BlendState", "GLPipe::BlendState *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__BlendState_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__DepthState = {"_p_GLPipe__DepthState", "GLPipe::DepthState *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__DepthState_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__FBO = {"_p_GLPipe__FBO", "GLPipe::FBO *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__FBO_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__Feedback = {"_p_GLPipe__Feedback", "GLPipe::Feedback *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__Feedback_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__FixedVertexProcessing = {"_p_GLPipe__FixedVertexProcessing", "GLPipe::FixedVertexProcessing *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__FixedVertexProcessing_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__FrameBuffer = {"_p_GLPipe__FrameBuffer", "GLPipe::FrameBuffer *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__FrameBuffer_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__Hints = {"_p_GLPipe__Hints", "GLPipe::Hints *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__Hints_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__Rasterizer = {"_p_GLPipe__Rasterizer", "GLPipe::Rasterizer *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__Rasterizer_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__RasterizerState = {"_p_GLPipe__RasterizerState", "GLPipe::RasterizerState *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__RasterizerState_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__Shader = {"_p_GLPipe__Shader", "GLPipe::Shader *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__Shader_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__State = {"_p_GLPipe__State", "GLPipe::State *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__State_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__StencilState = {"_p_GLPipe__StencilState", "GLPipe::StencilState *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__StencilState_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__TextureCompleteness = {"_p_GLPipe__TextureCompleteness", "GLPipe::TextureCompleteness *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__TextureCompleteness_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__VertexAttribute = {"_p_GLPipe__VertexAttribute", "GLPipe::VertexAttribute *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__VertexAttribute_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__VertexBuffer = {"_p_GLPipe__VertexBuffer", "GLPipe::VertexBuffer *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__VertexBuffer_clientdata, 0};
static swig_type_info _swigt__p_GLPipe__VertexInput = {"_p_GLPipe__VertexInput", "GLPipe::VertexInput *", 0, 0, (void*)&SwigPyBuiltin__GLPipe__VertexInput_clientdata, 0};
static swig_type_info _swigt__p_GPUCounter = {"_p_GPUCounter", "enum GPUCounter *|GPUCounter *", 0, 0, (void*)&SwigPyBuiltin__GPUCounter_clientdata, 0};
static swig_type_info _swigt__p_GPUDevice = {"_p_GPUDevice", "GPUDevice *", 0, 0, (void*)&SwigPyBuiltin__GPUDevice_clientdata, 0};
static swig_type_info _swigt__p_GPUVendor = {"_p_GPUVendor", "enum GPUVendor *|GPUVendor *", 0, 0, (void*)&SwigPyBuiltin__GPUVendor_clientdata, 0};
static swig_type_info _swigt__p_GlobalEnvironment = {"_p_GlobalEnvironment", "GlobalEnvironment *", 0, 0, (void*)&SwigPyBuiltin__GlobalEnvironment_clientdata, 0};
static swig_type_info _swigt__p_GraphicsAPI = {"_p_GraphicsAPI", "enum GraphicsAPI *|GraphicsAPI *", 0, 0, (void*)&SwigPyBuiltin__GraphicsAPI_clientdata, 0};
static swig_type_info _swigt__p_HWND__ = {"_p_HWND__", "HWND__ *|HWND", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ICamera = {"_p_ICamera", "ICamera *", 0, 0, (void*)&SwigPyBuiltin__ICamera_clientdata, 0};
static swig_type_info _swigt__p_ICaptureAccess = {"_p_ICaptureAccess", "ICaptureAccess *", 0, 0, (void*)&SwigPyBuiltin__ICaptureAccess_clientdata, 0};
static swig_type_info _swigt__p_ICaptureFile = {"_p_ICaptureFile", "ICaptureFile *", 0, 0, (void*)&SwigPyBuiltin__ICaptureFile_clientdata, 0};
static swig_type_info _swigt__p_IDeviceProtocolController = {"_p_IDeviceProtocolController", "IDeviceProtocolController *", 0, 0, (void*)&SwigPyBuiltin__IDeviceProtocolController_clientdata, 0};
static swig_type_info _swigt__p_IRemoteServer = {"_p_IRemoteServer", "IRemoteServer *", 0, 0, (void*)&SwigPyBuiltin__IRemoteServer_clientdata, 0};
static swig_type_info _swigt__p_IReplayController = {"_p_IReplayController", "IReplayController *", 0, 0, (void*)&SwigPyBuiltin__IReplayController_clientdata, 0};
static swig_type_info _swigt__p_IReplayOutput = {"_p_IReplayOutput", "IReplayOutput *", 0, 0, (void*)&SwigPyBuiltin__IReplayOutput_clientdata, 0};
static swig_type_info _swigt__p_ITargetControl = {"_p_ITargetControl", "ITargetControl *", 0, 0, (void*)&SwigPyBuiltin__ITargetControl_clientdata, 0};
static swig_type_info _swigt__p_IndexBindStats = {"_p_IndexBindStats", "IndexBindStats *", 0, 0, (void*)&SwigPyBuiltin__IndexBindStats_clientdata, 0};
static swig_type_info _swigt__p_InstructionSourceInfo = {"_p_InstructionSourceInfo", "InstructionSourceInfo *", 0, 0, (void*)&SwigPyBuiltin__InstructionSourceInfo_clientdata, 0};
static swig_type_info _swigt__p_KnownShaderTool = {"_p_KnownShaderTool", "enum KnownShaderTool *|KnownShaderTool *", 0, 0, (void*)&SwigPyBuiltin__KnownShaderTool_clientdata, 0};
static swig_type_info _swigt__p_LayoutBindStats = {"_p_LayoutBindStats", "LayoutBindStats *", 0, 0, (void*)&SwigPyBuiltin__LayoutBindStats_clientdata, 0};
static swig_type_info _swigt__p_LineColumnInfo = {"_p_LineColumnInfo", "LineColumnInfo *", 0, 0, (void*)&SwigPyBuiltin__LineColumnInfo_clientdata, 0};
static swig_type_info _swigt__p_LineRaster = {"_p_LineRaster", "enum LineRaster *|LineRaster *", 0, 0, (void*)&SwigPyBuiltin__LineRaster_clientdata, 0};
static swig_type_info _swigt__p_LogType = {"_p_LogType", "enum LogType *|LogType *", 0, 0, (void*)&SwigPyBuiltin__LogType_clientdata, 0};
static swig_type_info _swigt__p_LogicOperation = {"_p_LogicOperation", "enum LogicOperation *|LogicOperation *", 0, 0, (void*)&SwigPyBuiltin__LogicOperation_clientdata, 0};
static swig_type_info _swigt__p_MeshDataStage = {"_p_MeshDataStage", "enum MeshDataStage *|MeshDataStage *", 0, 0, (void*)&SwigPyBuiltin__MeshDataStage_clientdata, 0};
static swig_type_info _swigt__p_MeshDisplay = {"_p_MeshDisplay", "MeshDisplay *", 0, 0, (void*)&SwigPyBuiltin__MeshDisplay_clientdata, 0};
static swig_type_info _swigt__p_MeshFormat = {"_p_MeshFormat", "MeshFormat *", 0, 0, (void*)&SwigPyBuiltin__MeshFormat_clientdata, 0};
static swig_type_info _swigt__p_MeshletSize = {"_p_MeshletSize", "MeshletSize *", 0, 0, (void*)&SwigPyBuiltin__MeshletSize_clientdata, 0};
static swig_type_info _swigt__p_MessageCategory = {"_p_MessageCategory", "enum MessageCategory *|MessageCategory *", 0, 0, (void*)&SwigPyBuiltin__MessageCategory_clientdata, 0};
static swig_type_info _swigt__p_MessageSeverity = {"_p_MessageSeverity", "enum MessageSeverity *|MessageSeverity *", 0, 0, (void*)&SwigPyBuiltin__MessageSeverity_clientdata, 0};
static swig_type_info _swigt__p_MessageSource = {"_p_MessageSource", "enum MessageSource *|MessageSource *", 0, 0, (void*)&SwigPyBuiltin__MessageSource_clientdata, 0};
static swig_type_info _swigt__p_ModificationValue = {"_p_ModificationValue", "ModificationValue *", 0, 0, (void*)&SwigPyBuiltin__ModificationValue_clientdata, 0};
static swig_type_info _swigt__p_NewCaptureData = {"_p_NewCaptureData", "NewCaptureData *", 0, 0, (void*)&SwigPyBuiltin__NewCaptureData_clientdata, 0};
static swig_type_info _swigt__p_NewChildData = {"_p_NewChildData", "NewChildData *", 0, 0, (void*)&SwigPyBuiltin__NewChildData_clientdata, 0};
static swig_type_info _swigt__p_Offset = {"_p_Offset", "Offset *", 0, 0, (void*)&SwigPyBuiltin__Offset_clientdata, 0};
static swig_type_info _swigt__p_OutputTargetStats = {"_p_OutputTargetStats", "OutputTargetStats *", 0, 0, (void*)&SwigPyBuiltin__OutputTargetStats_clientdata, 0};
static swig_type_info _swigt__p_PathEntry = {"_p_PathEntry", "PathEntry *", 0, 0, (void*)&SwigPyBuiltin__PathEntry_clientdata, 0};
static swig_type_info _swigt__p_PathProperty = {"_p_PathProperty", "enum PathProperty *|PathProperty *", 0, 0, (void*)&SwigPyBuiltin__PathProperty_clientdata, 0};
static swig_type_info _swigt__p_PipeState = {"_p_PipeState", "PipeState *", 0, 0, (void*)&SwigPyBuiltin__PipeState_clientdata, 0};
static swig_type_info _swigt__p_PixelModification = {"_p_PixelModification", "PixelModification *", 0, 0, (void*)&SwigPyBuiltin__PixelModification_clientdata, 0};
static swig_type_info _swigt__p_PixelValue = {"_p_PixelValue", "PixelValue *", 0, 0, (void*)&SwigPyBuiltin__PixelValue_clientdata, 0};
static swig_type_info _swigt__p_PointerVal = {"_p_PointerVal", "PointerVal *", 0, 0, (void*)&SwigPyBuiltin__PointerVal_clientdata, 0};
static swig_type_info _swigt__p_QualityHint = {"_p_QualityHint", "enum QualityHint *|QualityHint *", 0, 0, (void*)&SwigPyBuiltin__QualityHint_clientdata, 0};
static swig_type_info _swigt__p_RasterState = {"_p_RasterState", "RasterState *", 0, 0, (void*)&SwigPyBuiltin__RasterState_clientdata, 0};
static swig_type_info _swigt__p_RasterizationStats = {"_p_RasterizationStats", "RasterizationStats *", 0, 0, (void*)&SwigPyBuiltin__RasterizationStats_clientdata, 0};
static swig_type_info _swigt__p_ReplayOptimisationLevel = {"_p_ReplayOptimisationLevel", "enum ReplayOptimisationLevel *|ReplayOptimisationLevel *", 0, 0, (void*)&SwigPyBuiltin__ReplayOptimisationLevel_clientdata, 0};
static swig_type_info _swigt__p_ReplayOptions = {"_p_ReplayOptions", "ReplayOptions *", 0, 0, (void*)&SwigPyBuiltin__ReplayOptions_clientdata, 0};
static swig_type_info _swigt__p_ReplayOutputType = {"_p_ReplayOutputType", "enum ReplayOutputType *|ReplayOutputType *", 0, 0, (void*)&SwigPyBuiltin__ReplayOutputType_clientdata, 0};
static swig_type_info _swigt__p_ReplaySupport = {"_p_ReplaySupport", "enum ReplaySupport *|ReplaySupport *", 0, 0, (void*)&SwigPyBuiltin__ReplaySupport_clientdata, 0};
static swig_type_info _swigt__p_ResourceBindStats = {"_p_ResourceBindStats", "ResourceBindStats *", 0, 0, (void*)&SwigPyBuiltin__ResourceBindStats_clientdata, 0};
static swig_type_info _swigt__p_ResourceDescription = {"_p_ResourceDescription", "ResourceDescription *", 0, 0, (void*)&SwigPyBuiltin__ResourceDescription_clientdata, 0};
static swig_type_info _swigt__p_ResourceFormat = {"_p_ResourceFormat", "ResourceFormat *", 0, 0, (void*)&SwigPyBuiltin__ResourceFormat_clientdata, 0};
static swig_type_info _swigt__p_ResourceFormatType = {"_p_ResourceFormatType", "enum ResourceFormatType *|ResourceFormatType *", 0, 0, (void*)&SwigPyBuiltin__ResourceFormatType_clientdata, 0};
static swig_type_info _swigt__p_ResourceId = {"_p_ResourceId", "ResourceId *", 0, 0, (void*)&SwigPyBuiltin__ResourceId_clientdata, 0};
static swig_type_info _swigt__p_ResourceType = {"_p_ResourceType", "enum ResourceType *|ResourceType *", 0, 0, (void*)&SwigPyBuiltin__ResourceType_clientdata, 0};
static swig_type_info _swigt__p_ResourceUpdateStats = {"_p_ResourceUpdateStats", "ResourceUpdateStats *", 0, 0, (void*)&SwigPyBuiltin__ResourceUpdateStats_clientdata, 0};
static swig_type_info _swigt__p_ResourceUsage = {"_p_ResourceUsage", "enum ResourceUsage *|ResourceUsage *", 0, 0, (void*)&SwigPyBuiltin__ResourceUsage_clientdata, 0};
static swig_type_info _swigt__p_ResultCode = {"_p_ResultCode", "enum ResultCode *|ResultCode *", 0, 0, (void*)&SwigPyBuiltin__ResultCode_clientdata, 0};
static swig_type_info _swigt__p_ResultDetails = {"_p_ResultDetails", "ResultDetails *", 0, 0, (void*)&SwigPyBuiltin__ResultDetails_clientdata, 0};
static swig_type_info _swigt__p_SDBasic = {"_p_SDBasic", "enum SDBasic *|SDBasic *", 0, 0, (void*)&SwigPyBuiltin__SDBasic_clientdata, 0};
static swig_type_info _swigt__p_SDChunk = {"_p_SDChunk", "SDChunk *", 0, 0, (void*)&SwigPyBuiltin__SDChunk_clientdata, 0};
static swig_type_info _swigt__p_SDChunkFlags = {"_p_SDChunkFlags", "enum SDChunkFlags *|SDChunkFlags *", 0, 0, (void*)&SwigPyBuiltin__SDChunkFlags_clientdata, 0};
static swig_type_info _swigt__p_SDChunkMetaData = {"_p_SDChunkMetaData", "SDChunkMetaData *", 0, 0, (void*)&SwigPyBuiltin__SDChunkMetaData_clientdata, 0};
static swig_type_info _swigt__p_SDFile = {"_p_SDFile", "SDFile *", 0, 0, (void*)&SwigPyBuiltin__SDFile_clientdata, 0};
static swig_type_info _swigt__p_SDObject = {"_p_SDObject", "SDObject *", 0, 0, (void*)&SwigPyBuiltin__SDObject_clientdata, 0};
static swig_type_info _swigt__p_SDObjectData = {"_p_SDObjectData", "SDObjectData *", 0, 0, (void*)&SwigPyBuiltin__SDObjectData_clientdata, 0};
static swig_type_info _swigt__p_SDObjectPODData = {"_p_SDObjectPODData", "SDObjectPODData *", 0, 0, (void*)&SwigPyBuiltin__SDObjectPODData_clientdata, 0};
static swig_type_info _swigt__p_SDType = {"_p_SDType", "SDType *", 0, 0, (void*)&SwigPyBuiltin__SDType_clientdata, 0};
static swig_type_info _swigt__p_SDTypeFlags = {"_p_SDTypeFlags", "enum SDTypeFlags *|SDTypeFlags *", 0, 0, (void*)&SwigPyBuiltin__SDTypeFlags_clientdata, 0};
static swig_type_info _swigt__p_SamplerBindStats = {"_p_SamplerBindStats", "SamplerBindStats *", 0, 0, (void*)&SwigPyBuiltin__SamplerBindStats_clientdata, 0};
static swig_type_info _swigt__p_SamplerDescriptor = {"_p_SamplerDescriptor", "SamplerDescriptor *", 0, 0, (void*)&SwigPyBuiltin__SamplerDescriptor_clientdata, 0};
static swig_type_info _swigt__p_Scissor = {"_p_Scissor", "Scissor *", 0, 0, (void*)&SwigPyBuiltin__Scissor_clientdata, 0};
static swig_type_info _swigt__p_SectionFlags = {"_p_SectionFlags", "enum SectionFlags *|SectionFlags *", 0, 0, (void*)&SwigPyBuiltin__SectionFlags_clientdata, 0};
static swig_type_info _swigt__p_SectionProperties = {"_p_SectionProperties", "SectionProperties *", 0, 0, (void*)&SwigPyBuiltin__SectionProperties_clientdata, 0};
static swig_type_info _swigt__p_SectionType = {"_p_SectionType", "enum SectionType *|SectionType *", 0, 0, (void*)&SwigPyBuiltin__SectionType_clientdata, 0};
static swig_type_info _swigt__p_ShaderBindIndex = {"_p_ShaderBindIndex", "ShaderBindIndex *", 0, 0, (void*)&SwigPyBuiltin__ShaderBindIndex_clientdata, 0};
static swig_type_info _swigt__p_ShaderBuiltin = {"_p_ShaderBuiltin", "enum ShaderBuiltin *|ShaderBuiltin *", 0, 0, (void*)&SwigPyBuiltin__ShaderBuiltin_clientdata, 0};
static swig_type_info _swigt__p_ShaderChangeStats = {"_p_ShaderChangeStats", "ShaderChangeStats *", 0, 0, (void*)&SwigPyBuiltin__ShaderChangeStats_clientdata, 0};
static swig_type_info _swigt__p_ShaderCompileFlag = {"_p_ShaderCompileFlag", "ShaderCompileFlag *", 0, 0, (void*)&SwigPyBuiltin__ShaderCompileFlag_clientdata, 0};
static swig_type_info _swigt__p_ShaderCompileFlags = {"_p_ShaderCompileFlags", "ShaderCompileFlags *", 0, 0, (void*)&SwigPyBuiltin__ShaderCompileFlags_clientdata, 0};
static swig_type_info _swigt__p_ShaderComputeMessageLocation = {"_p_ShaderComputeMessageLocation", "ShaderComputeMessageLocation *", 0, 0, (void*)&SwigPyBuiltin__ShaderComputeMessageLocation_clientdata, 0};
static swig_type_info _swigt__p_ShaderConstant = {"_p_ShaderConstant", "ShaderConstant *", 0, 0, (void*)&SwigPyBuiltin__ShaderConstant_clientdata, 0};
static swig_type_info _swigt__p_ShaderConstantType = {"_p_ShaderConstantType", "ShaderConstantType *", 0, 0, (void*)&SwigPyBuiltin__ShaderConstantType_clientdata, 0};
static swig_type_info _swigt__p_ShaderDebugInfo = {"_p_ShaderDebugInfo", "ShaderDebugInfo *", 0, 0, (void*)&SwigPyBuiltin__ShaderDebugInfo_clientdata, 0};
static swig_type_info _swigt__p_ShaderDebugState = {"_p_ShaderDebugState", "ShaderDebugState *", 0, 0, (void*)&SwigPyBuiltin__ShaderDebugState_clientdata, 0};
static swig_type_info _swigt__p_ShaderDebugTrace = {"_p_ShaderDebugTrace", "ShaderDebugTrace *", 0, 0, (void*)&SwigPyBuiltin__ShaderDebugTrace_clientdata, 0};
static swig_type_info _swigt__p_ShaderDebugger = {"_p_ShaderDebugger", "ShaderDebugger *", 0, 0, (void*)&SwigPyBuiltin__ShaderDebugger_clientdata, 0};
static swig_type_info _swigt__p_ShaderDirectAccess = {"_p_ShaderDirectAccess", "ShaderDirectAccess *", 0, 0, (void*)&SwigPyBuiltin__ShaderDirectAccess_clientdata, 0};
static swig_type_info _swigt__p_ShaderEncoding = {"_p_ShaderEncoding", "enum ShaderEncoding *|ShaderEncoding *", 0, 0, (void*)&SwigPyBuiltin__ShaderEncoding_clientdata, 0};
static swig_type_info _swigt__p_ShaderEntryPoint = {"_p_ShaderEntryPoint", "ShaderEntryPoint *", 0, 0, (void*)&SwigPyBuiltin__ShaderEntryPoint_clientdata, 0};
static swig_type_info _swigt__p_ShaderEvents = {"_p_ShaderEvents", "enum ShaderEvents *|ShaderEvents *", 0, 0, (void*)&SwigPyBuiltin__ShaderEvents_clientdata, 0};
static swig_type_info _swigt__p_ShaderGeometryMessageLocation = {"_p_ShaderGeometryMessageLocation", "ShaderGeometryMessageLocation *", 0, 0, (void*)&SwigPyBuiltin__ShaderGeometryMessageLocation_clientdata, 0};
static swig_type_info _swigt__p_ShaderMeshMessageLocation = {"_p_ShaderMeshMessageLocation", "ShaderMeshMessageLocation *", 0, 0, (void*)&SwigPyBuiltin__ShaderMeshMessageLocation_clientdata, 0};
static swig_type_info _swigt__p_ShaderMessage = {"_p_ShaderMessage", "ShaderMessage *", 0, 0, (void*)&SwigPyBuiltin__ShaderMessage_clientdata, 0};
static swig_type_info _swigt__p_ShaderMessageLocation = {"_p_ShaderMessageLocation", "ShaderMessageLocation *", 0, 0, (void*)&SwigPyBuiltin__ShaderMessageLocation_clientdata, 0};
static swig_type_info _swigt__p_ShaderPixelMessageLocation = {"_p_ShaderPixelMessageLocation", "ShaderPixelMessageLocation *", 0, 0, (void*)&SwigPyBuiltin__ShaderPixelMessageLocation_clientdata, 0};
static swig_type_info _swigt__p_ShaderReflection = {"_p_ShaderReflection", "ShaderReflection *", 0, 0, (void*)&SwigPyBuiltin__ShaderReflection_clientdata, 0};
static swig_type_info _swigt__p_ShaderResource = {"_p_ShaderResource", "ShaderResource *", 0, 0, (void*)&SwigPyBuiltin__ShaderResource_clientdata, 0};
static swig_type_info _swigt__p_ShaderSampler = {"_p_ShaderSampler", "ShaderSampler *", 0, 0, (void*)&SwigPyBuiltin__ShaderSampler_clientdata, 0};
static swig_type_info _swigt__p_ShaderSourceFile = {"_p_ShaderSourceFile", "ShaderSourceFile *", 0, 0, (void*)&SwigPyBuiltin__ShaderSourceFile_clientdata, 0};
static swig_type_info _swigt__p_ShaderSourcePrefix = {"_p_ShaderSourcePrefix", "ShaderSourcePrefix *", 0, 0, (void*)&SwigPyBuiltin__ShaderSourcePrefix_clientdata, 0};
static swig_type_info _swigt__p_ShaderStage = {"_p_ShaderStage", "enum ShaderStage *|ShaderStage *", 0, 0, (void*)&SwigPyBuiltin__ShaderStage_clientdata, 0};
static swig_type_info _swigt__p_ShaderStageMask = {"_p_ShaderStageMask", "enum ShaderStageMask *|ShaderStageMask *", 0, 0, (void*)&SwigPyBuiltin__ShaderStageMask_clientdata, 0};
static swig_type_info _swigt__p_ShaderValue = {"_p_ShaderValue", "ShaderValue *", 0, 0, (void*)&SwigPyBuiltin__ShaderValue_clientdata, 0};
static swig_type_info _swigt__p_ShaderVariable = {"_p_ShaderVariable", "ShaderVariable *", 0, 0, (void*)&SwigPyBuiltin__ShaderVariable_clientdata, 0};
static swig_type_info _swigt__p_ShaderVariableChange = {"_p_ShaderVariableChange", "ShaderVariableChange *", 0, 0, (void*)&SwigPyBuiltin__ShaderVariableChange_clientdata, 0};
static swig_type_info _swigt__p_ShaderVariableFlags = {"_p_ShaderVariableFlags", "enum ShaderVariableFlags *|ShaderVariableFlags *", 0, 0, (void*)&SwigPyBuiltin__ShaderVariableFlags_clientdata, 0};
static swig_type_info _swigt__p_ShaderVertexMessageLocation = {"_p_ShaderVertexMessageLocation", "ShaderVertexMessageLocation *", 0, 0, (void*)&SwigPyBuiltin__ShaderVertexMessageLocation_clientdata, 0};
static swig_type_info _swigt__p_ShadingRateCombiner = {"_p_ShadingRateCombiner", "enum ShadingRateCombiner *|ShadingRateCombiner *", 0, 0, (void*)&SwigPyBuiltin__ShadingRateCombiner_clientdata, 0};
static swig_type_info _swigt__p_SigParameter = {"_p_SigParameter", "SigParameter *", 0, 0, (void*)&SwigPyBuiltin__SigParameter_clientdata, 0};
static swig_type_info _swigt__p_SourceVariableMapping = {"_p_SourceVariableMapping", "SourceVariableMapping *", 0, 0, (void*)&SwigPyBuiltin__SourceVariableMapping_clientdata, 0};
static swig_type_info _swigt__p_StencilFace = {"_p_StencilFace", "StencilFace *", 0, 0, (void*)&SwigPyBuiltin__StencilFace_clientdata, 0};
static swig_type_info _swigt__p_StencilOperation = {"_p_StencilOperation", "enum StencilOperation *|StencilOperation *", 0, 0, (void*)&SwigPyBuiltin__StencilOperation_clientdata, 0};
static swig_type_info _swigt__p_StructuredBufferList = {"_p_StructuredBufferList", "StructuredBufferList *", 0, 0, (void*)&SwigPyBuiltin__StructuredBufferList_clientdata, 0};
static swig_type_info _swigt__p_StructuredChunkList = {"_p_StructuredChunkList", "StructuredChunkList *", 0, 0, (void*)&SwigPyBuiltin__StructuredChunkList_clientdata, 0};
static swig_type_info _swigt__p_StructuredObjectList = {"_p_StructuredObjectList", "StructuredObjectList *", 0, 0, (void*)&SwigPyBuiltin__StructuredObjectList_clientdata, 0};
static swig_type_info _swigt__p_Subresource = {"_p_Subresource", "Subresource *", 0, 0, (void*)&SwigPyBuiltin__Subresource_clientdata, 0};
static swig_type_info _swigt__p_SwigPyObject = {"_p_SwigPyObject", "SwigPyObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TargetControlMessage = {"_p_TargetControlMessage", "TargetControlMessage *", 0, 0, (void*)&SwigPyBuiltin__TargetControlMessage_clientdata, 0};
static swig_type_info _swigt__p_TargetControlMessageType = {"_p_TargetControlMessageType", "enum TargetControlMessageType *|TargetControlMessageType *", 0, 0, (void*)&SwigPyBuiltin__TargetControlMessageType_clientdata, 0};
static swig_type_info _swigt__p_TaskGroupSize = {"_p_TaskGroupSize", "TaskGroupSize *", 0, 0, (void*)&SwigPyBuiltin__TaskGroupSize_clientdata, 0};
static swig_type_info _swigt__p_TextureCategory = {"_p_TextureCategory", "enum TextureCategory *|TextureCategory *", 0, 0, (void*)&SwigPyBuiltin__TextureCategory_clientdata, 0};
static swig_type_info _swigt__p_TextureComponentMapping = {"_p_TextureComponentMapping", "TextureComponentMapping *", 0, 0, (void*)&SwigPyBuiltin__TextureComponentMapping_clientdata, 0};
static swig_type_info _swigt__p_TextureDescription = {"_p_TextureDescription", "TextureDescription *", 0, 0, (void*)&SwigPyBuiltin__TextureDescription_clientdata, 0};
static swig_type_info _swigt__p_TextureDisplay = {"_p_TextureDisplay", "TextureDisplay *", 0, 0, (void*)&SwigPyBuiltin__TextureDisplay_clientdata, 0};
static swig_type_info _swigt__p_TextureFilter = {"_p_TextureFilter", "TextureFilter *", 0, 0, (void*)&SwigPyBuiltin__TextureFilter_clientdata, 0};
static swig_type_info _swigt__p_TextureSampleMapping = {"_p_TextureSampleMapping", "TextureSampleMapping *", 0, 0, (void*)&SwigPyBuiltin__TextureSampleMapping_clientdata, 0};
static swig_type_info _swigt__p_TextureSave = {"_p_TextureSave", "TextureSave *", 0, 0, (void*)&SwigPyBuiltin__TextureSave_clientdata, 0};
static swig_type_info _swigt__p_TextureSliceMapping = {"_p_TextureSliceMapping", "TextureSliceMapping *", 0, 0, (void*)&SwigPyBuiltin__TextureSliceMapping_clientdata, 0};
static swig_type_info _swigt__p_TextureSwizzle = {"_p_TextureSwizzle", "enum TextureSwizzle *|TextureSwizzle *", 0, 0, (void*)&SwigPyBuiltin__TextureSwizzle_clientdata, 0};
static swig_type_info _swigt__p_TextureSwizzle4 = {"_p_TextureSwizzle4", "TextureSwizzle4 *", 0, 0, (void*)&SwigPyBuiltin__TextureSwizzle4_clientdata, 0};
static swig_type_info _swigt__p_TextureType = {"_p_TextureType", "enum TextureType *|TextureType *", 0, 0, (void*)&SwigPyBuiltin__TextureType_clientdata, 0};
static swig_type_info _swigt__p_Thumbnail = {"_p_Thumbnail", "Thumbnail *", 0, 0, (void*)&SwigPyBuiltin__Thumbnail_clientdata, 0};
static swig_type_info _swigt__p_Topology = {"_p_Topology", "enum Topology *|Topology *", 0, 0, (void*)&SwigPyBuiltin__Topology_clientdata, 0};
static swig_type_info _swigt__p_UsedDescriptor = {"_p_UsedDescriptor", "UsedDescriptor *", 0, 0, (void*)&SwigPyBuiltin__UsedDescriptor_clientdata, 0};
static swig_type_info _swigt__p_Uuid = {"_p_Uuid", "Uuid *", 0, 0, (void*)&SwigPyBuiltin__Uuid_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__ColorBlendState = {"_p_VKPipe__ColorBlendState", "VKPipe::ColorBlendState *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__ColorBlendState_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__ConditionalRendering = {"_p_VKPipe__ConditionalRendering", "VKPipe::ConditionalRendering *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__ConditionalRendering_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__CurrentPass = {"_p_VKPipe__CurrentPass", "VKPipe::CurrentPass *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__CurrentPass_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__DepthStencil = {"_p_VKPipe__DepthStencil", "VKPipe::DepthStencil *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__DepthStencil_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__DescriptorBuffer = {"_p_VKPipe__DescriptorBuffer", "VKPipe::DescriptorBuffer *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__DescriptorBuffer_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__DescriptorSet = {"_p_VKPipe__DescriptorSet", "VKPipe::DescriptorSet *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__DescriptorSet_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__DynamicOffset = {"_p_VKPipe__DynamicOffset", "VKPipe::DynamicOffset *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__DynamicOffset_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__Framebuffer = {"_p_VKPipe__Framebuffer", "VKPipe::Framebuffer *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__Framebuffer_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__ImageData = {"_p_VKPipe__ImageData", "VKPipe::ImageData *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__ImageData_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__ImageLayout = {"_p_VKPipe__ImageLayout", "VKPipe::ImageLayout *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__ImageLayout_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__IndexBuffer = {"_p_VKPipe__IndexBuffer", "VKPipe::IndexBuffer *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__IndexBuffer_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__InputAssembly = {"_p_VKPipe__InputAssembly", "VKPipe::InputAssembly *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__InputAssembly_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__MultiSample = {"_p_VKPipe__MultiSample", "VKPipe::MultiSample *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__MultiSample_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__Pipeline = {"_p_VKPipe__Pipeline", "VKPipe::Pipeline *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__Pipeline_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__Rasterizer = {"_p_VKPipe__Rasterizer", "VKPipe::Rasterizer *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__Rasterizer_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__RenderArea = {"_p_VKPipe__RenderArea", "VKPipe::RenderArea *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__RenderArea_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__RenderPass = {"_p_VKPipe__RenderPass", "VKPipe::RenderPass *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__RenderPass_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__SampleLocations = {"_p_VKPipe__SampleLocations", "VKPipe::SampleLocations *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__SampleLocations_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__Shader = {"_p_VKPipe__Shader", "VKPipe::Shader *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__Shader_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__State = {"_p_VKPipe__State", "VKPipe::State *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__State_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__Tessellation = {"_p_VKPipe__Tessellation", "VKPipe::Tessellation *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__Tessellation_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__TransformFeedback = {"_p_VKPipe__TransformFeedback", "VKPipe::TransformFeedback *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__TransformFeedback_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__VertexAttribute = {"_p_VKPipe__VertexAttribute", "VKPipe::VertexAttribute *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__VertexAttribute_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__VertexBinding = {"_p_VKPipe__VertexBinding", "VKPipe::VertexBinding *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__VertexBinding_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__VertexBuffer = {"_p_VKPipe__VertexBuffer", "VKPipe::VertexBuffer *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__VertexBuffer_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__VertexInput = {"_p_VKPipe__VertexInput", "VKPipe::VertexInput *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__VertexInput_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__ViewState = {"_p_VKPipe__ViewState", "VKPipe::ViewState *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__ViewState_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__ViewportScissor = {"_p_VKPipe__ViewportScissor", "VKPipe::ViewportScissor *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__ViewportScissor_clientdata, 0};
static swig_type_info _swigt__p_VKPipe__XFBBuffer = {"_p_VKPipe__XFBBuffer", "VKPipe::XFBBuffer *", 0, 0, (void*)&SwigPyBuiltin__VKPipe__XFBBuffer_clientdata, 0};
static swig_type_info _swigt__p_VarType = {"_p_VarType", "enum VarType *|VarType *", 0, 0, (void*)&SwigPyBuiltin__VarType_clientdata, 0};
static swig_type_info _swigt__p_VertexBindStats = {"_p_VertexBindStats", "VertexBindStats *", 0, 0, (void*)&SwigPyBuiltin__VertexBindStats_clientdata, 0};
static swig_type_info _swigt__p_VertexInputAttribute = {"_p_VertexInputAttribute", "VertexInputAttribute *", 0, 0, (void*)&SwigPyBuiltin__VertexInputAttribute_clientdata, 0};
static swig_type_info _swigt__p_Viewport = {"_p_Viewport", "Viewport *", 0, 0, (void*)&SwigPyBuiltin__Viewport_clientdata, 0};
static swig_type_info _swigt__p_Visualisation = {"_p_Visualisation", "enum Visualisation *|Visualisation *", 0, 0, (void*)&SwigPyBuiltin__Visualisation_clientdata, 0};
static swig_type_info _swigt__p_VulkanLayerFlags = {"_p_VulkanLayerFlags", "enum VulkanLayerFlags *|VulkanLayerFlags *", 0, 0, (void*)&SwigPyBuiltin__VulkanLayerFlags_clientdata, 0};
static swig_type_info _swigt__p_VulkanLayerRegistrationInfo = {"_p_VulkanLayerRegistrationInfo", "VulkanLayerRegistrationInfo *", 0, 0, (void*)&SwigPyBuiltin__VulkanLayerRegistrationInfo_clientdata, 0};
static swig_type_info _swigt__p_WindowingData = {"_p_WindowingData", "WindowingData *", 0, 0, (void*)&SwigPyBuiltin__WindowingData_clientdata, 0};
static swig_type_info _swigt__p_WindowingSystem = {"_p_WindowingSystem", "enum WindowingSystem *|WindowingSystem *", 0, 0, (void*)&SwigPyBuiltin__WindowingSystem_clientdata, 0};
static swig_type_info _swigt__p_YcbcrConversion = {"_p_YcbcrConversion", "enum YcbcrConversion *|YcbcrConversion *", 0, 0, (void*)&SwigPyBuiltin__YcbcrConversion_clientdata, 0};
static swig_type_info _swigt__p_YcbcrRange = {"_p_YcbcrRange", "enum YcbcrRange *|YcbcrRange *", 0, 0, (void*)&SwigPyBuiltin__YcbcrRange_clientdata, 0};
static swig_type_info _swigt__p__XDisplay = {"_p__XDisplay", "_XDisplay *|Display *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bytebuf = {"_p_bytebuf", "bytebuf *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *|int_least32_t *|int32_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long = {"_p_long", "intptr_t *|int_least64_t *|int_fast32_t *|int_fast64_t *|int64_t *|long *|int_fast16_t *|intmax_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_IRemoteServer = {"_p_p_IRemoteServer", "IRemoteServer **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcarrayT_APIEvent_t = {"_p_rdcarrayT_APIEvent_t", "rdcarray< APIEvent > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_APIEvent_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ActionDescription_t = {"_p_rdcarrayT_ActionDescription_t", "rdcarray< ActionDescription > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ActionDescription_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_BoundVBuffer_t = {"_p_rdcarrayT_BoundVBuffer_t", "rdcarray< BoundVBuffer > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_BufferDescription_t = {"_p_rdcarrayT_BufferDescription_t", "rdcarray< BufferDescription > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_BufferDescription_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_CaptureFileFormat_t = {"_p_rdcarrayT_CaptureFileFormat_t", "rdcarray< CaptureFileFormat > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ColorBlend_t = {"_p_rdcarrayT_ColorBlend_t", "rdcarray< ColorBlend > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ColorBlend_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ConstantBindStats_t = {"_p_rdcarrayT_ConstantBindStats_t", "rdcarray< ConstantBindStats > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ConstantBlock_t = {"_p_rdcarrayT_ConstantBlock_t", "rdcarray< ConstantBlock > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ConstantBlock_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_CounterResult_t = {"_p_rdcarrayT_CounterResult_t", "rdcarray< CounterResult > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_CounterResult_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_D3D11Pipe__Layout_t = {"_p_rdcarrayT_D3D11Pipe__Layout_t", "rdcarray< D3D11Pipe::Layout > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_D3D11Pipe__StreamOutBind_t = {"_p_rdcarrayT_D3D11Pipe__StreamOutBind_t", "rdcarray< D3D11Pipe::StreamOutBind > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_D3D11Pipe__VertexBuffer_t = {"_p_rdcarrayT_D3D11Pipe__VertexBuffer_t", "rdcarray< D3D11Pipe::VertexBuffer > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_D3D12Pipe__Layout_t = {"_p_rdcarrayT_D3D12Pipe__Layout_t", "rdcarray< D3D12Pipe::Layout > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_D3D12Pipe__ResourceData_t = {"_p_rdcarrayT_D3D12Pipe__ResourceData_t", "rdcarray< D3D12Pipe::ResourceData > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_D3D12Pipe__ResourceState_t = {"_p_rdcarrayT_D3D12Pipe__ResourceState_t", "rdcarray< D3D12Pipe::ResourceState > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_D3D12Pipe__RootParam_t = {"_p_rdcarrayT_D3D12Pipe__RootParam_t", "rdcarray< D3D12Pipe::RootParam > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_D3D12Pipe__RootTableRange_t = {"_p_rdcarrayT_D3D12Pipe__RootTableRange_t", "rdcarray< D3D12Pipe::RootTableRange > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_D3D12Pipe__StaticSampler_t = {"_p_rdcarrayT_D3D12Pipe__StaticSampler_t", "rdcarray< D3D12Pipe::StaticSampler > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_D3D12Pipe__StreamOutBind_t = {"_p_rdcarrayT_D3D12Pipe__StreamOutBind_t", "rdcarray< D3D12Pipe::StreamOutBind > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_D3D12Pipe__VertexBuffer_t = {"_p_rdcarrayT_D3D12Pipe__VertexBuffer_t", "rdcarray< D3D12Pipe::VertexBuffer > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_DebugMessage_t = {"_p_rdcarrayT_DebugMessage_t", "rdcarray< DebugMessage > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_DebugMessage_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_DebugVariableReference_t = {"_p_rdcarrayT_DebugVariableReference_t", "rdcarray< DebugVariableReference > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_DescriptorAccess_t = {"_p_rdcarrayT_DescriptorAccess_t", "rdcarray< DescriptorAccess > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_DescriptorLogicalLocation_t = {"_p_rdcarrayT_DescriptorLogicalLocation_t", "rdcarray< DescriptorLogicalLocation > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_DescriptorRange_t = {"_p_rdcarrayT_DescriptorRange_t", "rdcarray< DescriptorRange > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_DescriptorRange_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_DescriptorStoreDescription_t = {"_p_rdcarrayT_DescriptorStoreDescription_t", "rdcarray< DescriptorStoreDescription > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_Descriptor_t = {"_p_rdcarrayT_Descriptor_t", "rdcarray< Descriptor > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_Descriptor_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_EnvironmentModification_t = {"_p_rdcarrayT_EnvironmentModification_t", "rdcarray< EnvironmentModification > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_EventUsage_t = {"_p_rdcarrayT_EventUsage_t", "rdcarray< EventUsage > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_EventUsage_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_FloatVector_t = {"_p_rdcarrayT_FloatVector_t", "rdcarray< FloatVector > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_FloatVector_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_GLPipe__TextureCompleteness_t = {"_p_rdcarrayT_GLPipe__TextureCompleteness_t", "rdcarray< GLPipe::TextureCompleteness > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_GLPipe__VertexAttribute_t = {"_p_rdcarrayT_GLPipe__VertexAttribute_t", "rdcarray< GLPipe::VertexAttribute > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_GLPipe__VertexBuffer_t = {"_p_rdcarrayT_GLPipe__VertexBuffer_t", "rdcarray< GLPipe::VertexBuffer > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_GPUCounter_t = {"_p_rdcarrayT_GPUCounter_t", "rdcarray< enum GPUCounter > *|rdcarray< GPUCounter > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_GPUCounter_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_GPUDevice_t = {"_p_rdcarrayT_GPUDevice_t", "rdcarray< GPUDevice > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_GPUDevice_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_GraphicsAPI_t = {"_p_rdcarrayT_GraphicsAPI_t", "rdcarray< enum GraphicsAPI > *|rdcarray< GraphicsAPI > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_InstructionSourceInfo_t = {"_p_rdcarrayT_InstructionSourceInfo_t", "rdcarray< InstructionSourceInfo > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_LineColumnInfo_t = {"_p_rdcarrayT_LineColumnInfo_t", "rdcarray< LineColumnInfo > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_MeshletSize_t = {"_p_rdcarrayT_MeshletSize_t", "rdcarray< MeshletSize > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_MeshletSize_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_Offset_t = {"_p_rdcarrayT_Offset_t", "rdcarray< Offset > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_Offset_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_PathEntry_t = {"_p_rdcarrayT_PathEntry_t", "rdcarray< PathEntry > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_PathEntry_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_PixelModification_t = {"_p_rdcarrayT_PixelModification_t", "rdcarray< PixelModification > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_PixelModification_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ResourceBindStats_t = {"_p_rdcarrayT_ResourceBindStats_t", "rdcarray< ResourceBindStats > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ResourceDescription_t = {"_p_rdcarrayT_ResourceDescription_t", "rdcarray< ResourceDescription > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ResourceDescription_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ResourceId_t = {"_p_rdcarrayT_ResourceId_t", "rdcarray< ResourceId > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ResourceId_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_SamplerBindStats_t = {"_p_rdcarrayT_SamplerBindStats_t", "rdcarray< SamplerBindStats > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_SamplerDescriptor_t = {"_p_rdcarrayT_SamplerDescriptor_t", "rdcarray< SamplerDescriptor > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_Scissor_t = {"_p_rdcarrayT_Scissor_t", "rdcarray< Scissor > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_Scissor_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderChangeStats_t = {"_p_rdcarrayT_ShaderChangeStats_t", "rdcarray< ShaderChangeStats > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderCompileFlag_t = {"_p_rdcarrayT_ShaderCompileFlag_t", "rdcarray< ShaderCompileFlag > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderConstantType_t = {"_p_rdcarrayT_ShaderConstantType_t", "rdcarray< ShaderConstantType > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderConstant_t = {"_p_rdcarrayT_ShaderConstant_t", "rdcarray< ShaderConstant > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderConstant_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderDebugState_t = {"_p_rdcarrayT_ShaderDebugState_t", "rdcarray< ShaderDebugState > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderEncoding_t = {"_p_rdcarrayT_ShaderEncoding_t", "rdcarray< enum ShaderEncoding > *|rdcarray< ShaderEncoding > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderEntryPoint_t = {"_p_rdcarrayT_ShaderEntryPoint_t", "rdcarray< ShaderEntryPoint > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderMessage_t = {"_p_rdcarrayT_ShaderMessage_t", "rdcarray< ShaderMessage > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderMessage_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderResource_t = {"_p_rdcarrayT_ShaderResource_t", "rdcarray< ShaderResource > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderResource_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderSampler_t = {"_p_rdcarrayT_ShaderSampler_t", "rdcarray< ShaderSampler > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderSampler_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderSourceFile_t = {"_p_rdcarrayT_ShaderSourceFile_t", "rdcarray< ShaderSourceFile > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderSourcePrefix_t = {"_p_rdcarrayT_ShaderSourcePrefix_t", "rdcarray< ShaderSourcePrefix > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderVariableChange_t = {"_p_rdcarrayT_ShaderVariableChange_t", "rdcarray< ShaderVariableChange > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_ShaderVariable_t = {"_p_rdcarrayT_ShaderVariable_t", "rdcarray< ShaderVariable > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_ShaderVariable_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_SigParameter_t = {"_p_rdcarrayT_SigParameter_t", "rdcarray< SigParameter > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_SigParameter_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_SourceVariableMapping_t = {"_p_rdcarrayT_SourceVariableMapping_t", "rdcarray< SourceVariableMapping > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_TaskGroupSize_t = {"_p_rdcarrayT_TaskGroupSize_t", "rdcarray< TaskGroupSize > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_TextureDescription_t = {"_p_rdcarrayT_TextureDescription_t", "rdcarray< TextureDescription > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_TextureDescription_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_UsedDescriptor_t = {"_p_rdcarrayT_UsedDescriptor_t", "rdcarray< UsedDescriptor > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_VKPipe__DescriptorBuffer_t = {"_p_rdcarrayT_VKPipe__DescriptorBuffer_t", "rdcarray< VKPipe::DescriptorBuffer > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_VKPipe__DescriptorSet_t = {"_p_rdcarrayT_VKPipe__DescriptorSet_t", "rdcarray< VKPipe::DescriptorSet > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_VKPipe__DynamicOffset_t = {"_p_rdcarrayT_VKPipe__DynamicOffset_t", "rdcarray< VKPipe::DynamicOffset > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_VKPipe__ImageData_t = {"_p_rdcarrayT_VKPipe__ImageData_t", "rdcarray< VKPipe::ImageData > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_VKPipe__ImageLayout_t = {"_p_rdcarrayT_VKPipe__ImageLayout_t", "rdcarray< VKPipe::ImageLayout > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_VKPipe__RenderArea_t = {"_p_rdcarrayT_VKPipe__RenderArea_t", "rdcarray< VKPipe::RenderArea > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_VKPipe__VertexAttribute_t = {"_p_rdcarrayT_VKPipe__VertexAttribute_t", "rdcarray< VKPipe::VertexAttribute > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_VKPipe__VertexBinding_t = {"_p_rdcarrayT_VKPipe__VertexBinding_t", "rdcarray< VKPipe::VertexBinding > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_VKPipe__VertexBuffer_t = {"_p_rdcarrayT_VKPipe__VertexBuffer_t", "rdcarray< VKPipe::VertexBuffer > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_VKPipe__ViewportScissor_t = {"_p_rdcarrayT_VKPipe__ViewportScissor_t", "rdcarray< VKPipe::ViewportScissor > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_VKPipe__XFBBuffer_t = {"_p_rdcarrayT_VKPipe__XFBBuffer_t", "rdcarray< VKPipe::XFBBuffer > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_VertexInputAttribute_t = {"_p_rdcarrayT_VertexInputAttribute_t", "rdcarray< VertexInputAttribute > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_Viewport_t = {"_p_rdcarrayT_Viewport_t", "rdcarray< Viewport > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_Viewport_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_WindowingSystem_t = {"_p_rdcarrayT_WindowingSystem_t", "rdcarray< enum WindowingSystem > *|rdcarray< WindowingSystem > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_WindowingSystem_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_float_t = {"_p_rdcarrayT_float_t", "rdcarray< float > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_float_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_int_t = {"_p_rdcarrayT_int_t", "rdcarray< int32_t > *|rdcarray< int > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_int_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_rdcstr_t = {"_p_rdcarrayT_rdcstr_t", "rdcarray< rdcstr > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_rdcstr_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_unsigned_int_t = {"_p_rdcarrayT_unsigned_int_t", "rdcarray< uint32_t > *|rdcarray< unsigned int > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_uint32_t_t_clientdata, 0};
static swig_type_info _swigt__p_rdcarrayT_unsigned_long_t = {"_p_rdcarrayT_unsigned_long_t", "rdcarray< unsigned long > *|rdcarray< uint64_t > *", 0, 0, (void*)&SwigPyBuiltin__rdcarrayT_uint64_t_t_clientdata, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_ResourceId_4_t = {"_p_rdcfixedarrayT_ResourceId_4_t", "rdcfixedarray< ResourceId,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_ResourceId_8_t = {"_p_rdcfixedarrayT_ResourceId_8_t", "rdcfixedarray< ResourceId,8 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_bool_4_t = {"_p_rdcfixedarrayT_bool_4_t", "rdcfixedarray< bool,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_bool_8_t = {"_p_rdcfixedarrayT_bool_8_t", "rdcfixedarray< bool,8 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_double_16_t = {"_p_rdcfixedarrayT_double_16_t", "rdcfixedarray< double,16 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_float_16_t = {"_p_rdcfixedarrayT_float_16_t", "rdcfixedarray< float,16 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_float_2_t = {"_p_rdcfixedarrayT_float_2_t", "rdcfixedarray< float,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_float_4_t = {"_p_rdcfixedarrayT_float_4_t", "rdcfixedarray< float,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_int_16_t = {"_p_rdcfixedarrayT_int_16_t", "rdcfixedarray< int,16 > *|rdcfixedarray< int32_t,16 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_int_4_t = {"_p_rdcfixedarrayT_int_4_t", "rdcfixedarray< int,4 > *|rdcfixedarray< int32_t,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_long_16_t = {"_p_rdcfixedarrayT_long_16_t", "rdcfixedarray< long,16 > *|rdcfixedarray< int64_t,16 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_rdhalf_16_t = {"_p_rdcfixedarrayT_rdhalf_16_t", "rdcfixedarray< rdhalf,16 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_short_16_t = {"_p_rdcfixedarrayT_short_16_t", "rdcfixedarray< short,16 > *|rdcfixedarray< int16_t,16 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_signed_char_16_t = {"_p_rdcfixedarrayT_signed_char_16_t", "rdcfixedarray< signed char,16 > *|rdcfixedarray< int8_t,16 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_unsigned_char_16_t = {"_p_rdcfixedarrayT_unsigned_char_16_t", "rdcfixedarray< unsigned char,16 > *|rdcfixedarray< uint8_t,16 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_unsigned_int_16_t = {"_p_rdcfixedarrayT_unsigned_int_16_t", "rdcfixedarray< unsigned int,16 > *|rdcfixedarray< uint32_t,16 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_unsigned_int_3_t = {"_p_rdcfixedarrayT_unsigned_int_3_t", "rdcfixedarray< unsigned int,3 > *|rdcfixedarray< uint32_t,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_unsigned_int_4_t = {"_p_rdcfixedarrayT_unsigned_int_4_t", "rdcfixedarray< unsigned int,4 > *|rdcfixedarray< uint32_t,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_unsigned_long_16_t = {"_p_rdcfixedarrayT_unsigned_long_16_t", "rdcfixedarray< unsigned long,16 > *|rdcfixedarray< uint64_t,16 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_unsigned_long_4_t = {"_p_rdcfixedarrayT_unsigned_long_4_t", "rdcfixedarray< unsigned long,4 > *|rdcfixedarray< uint64_t,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcfixedarrayT_unsigned_short_16_t = {"_p_rdcfixedarrayT_unsigned_short_16_t", "rdcfixedarray< unsigned short,16 > *|rdcfixedarray< uint16_t,16 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcinflexiblestr = {"_p_rdcinflexiblestr", "rdcinflexiblestr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcpairT_ShadingRateCombiner_ShadingRateCombiner_t = {"_p_rdcpairT_ShadingRateCombiner_ShadingRateCombiner_t", "rdcpair< enum ShadingRateCombiner,enum ShadingRateCombiner > *|rdcpair< ShadingRateCombiner,ShadingRateCombiner > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcpairT_unsigned_int_unsigned_int_t = {"_p_rdcpairT_unsigned_int_unsigned_int_t", "rdcpair< uint32_t,uint32_t > *|rdcpair< unsigned int,unsigned int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rdcstr = {"_p_rdcstr", "rdcstr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_WindowingData_fbool_rdcarrayT_WindowingSystem_t_const_RF_t = {"_p_std__functionT_WindowingData_fbool_rdcarrayT_WindowingSystem_t_const_RF_t", "RENDERDOC_PreviewWindowCallback *|std::function< WindowingData (bool,rdcarray< WindowingSystem > const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fAPIEvent_const_RF_t = {"_p_std__functionT_bool_fAPIEvent_const_RF_t", "std::function< bool (APIEvent const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fActionDescription_const_RF_t = {"_p_std__functionT_bool_fActionDescription_const_RF_t", "std::function< bool (ActionDescription const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fBoundVBuffer_const_RF_t = {"_p_std__functionT_bool_fBoundVBuffer_const_RF_t", "std::function< bool (BoundVBuffer const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fBufferDescription_const_RF_t = {"_p_std__functionT_bool_fBufferDescription_const_RF_t", "std::function< bool (BufferDescription const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fCaptureFileFormat_const_RF_t = {"_p_std__functionT_bool_fCaptureFileFormat_const_RF_t", "std::function< bool (CaptureFileFormat const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fColorBlend_const_RF_t = {"_p_std__functionT_bool_fColorBlend_const_RF_t", "std::function< bool (ColorBlend const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fConstantBindStats_const_RF_t = {"_p_std__functionT_bool_fConstantBindStats_const_RF_t", "std::function< bool (ConstantBindStats const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fConstantBlock_const_RF_t = {"_p_std__functionT_bool_fConstantBlock_const_RF_t", "std::function< bool (ConstantBlock const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fCounterResult_const_RF_t = {"_p_std__functionT_bool_fCounterResult_const_RF_t", "std::function< bool (CounterResult const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fD3D11Pipe__Layout_const_RF_t = {"_p_std__functionT_bool_fD3D11Pipe__Layout_const_RF_t", "std::function< bool (D3D11Pipe::Layout const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fD3D11Pipe__StreamOutBind_const_RF_t = {"_p_std__functionT_bool_fD3D11Pipe__StreamOutBind_const_RF_t", "std::function< bool (D3D11Pipe::StreamOutBind const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fD3D11Pipe__VertexBuffer_const_RF_t = {"_p_std__functionT_bool_fD3D11Pipe__VertexBuffer_const_RF_t", "std::function< bool (D3D11Pipe::VertexBuffer const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fD3D12Pipe__Layout_const_RF_t = {"_p_std__functionT_bool_fD3D12Pipe__Layout_const_RF_t", "std::function< bool (D3D12Pipe::Layout const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fD3D12Pipe__ResourceData_const_RF_t = {"_p_std__functionT_bool_fD3D12Pipe__ResourceData_const_RF_t", "std::function< bool (D3D12Pipe::ResourceData const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fD3D12Pipe__ResourceState_const_RF_t = {"_p_std__functionT_bool_fD3D12Pipe__ResourceState_const_RF_t", "std::function< bool (D3D12Pipe::ResourceState const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fD3D12Pipe__RootParam_const_RF_t = {"_p_std__functionT_bool_fD3D12Pipe__RootParam_const_RF_t", "std::function< bool (D3D12Pipe::RootParam const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fD3D12Pipe__RootTableRange_const_RF_t = {"_p_std__functionT_bool_fD3D12Pipe__RootTableRange_const_RF_t", "std::function< bool (D3D12Pipe::RootTableRange const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fD3D12Pipe__StaticSampler_const_RF_t = {"_p_std__functionT_bool_fD3D12Pipe__StaticSampler_const_RF_t", "std::function< bool (D3D12Pipe::StaticSampler const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fD3D12Pipe__StreamOutBind_const_RF_t = {"_p_std__functionT_bool_fD3D12Pipe__StreamOutBind_const_RF_t", "std::function< bool (D3D12Pipe::StreamOutBind const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fD3D12Pipe__VertexBuffer_const_RF_t = {"_p_std__functionT_bool_fD3D12Pipe__VertexBuffer_const_RF_t", "std::function< bool (D3D12Pipe::VertexBuffer const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fDebugMessage_const_RF_t = {"_p_std__functionT_bool_fDebugMessage_const_RF_t", "std::function< bool (DebugMessage const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fDebugVariableReference_const_RF_t = {"_p_std__functionT_bool_fDebugVariableReference_const_RF_t", "std::function< bool (DebugVariableReference const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fDescriptorAccess_const_RF_t = {"_p_std__functionT_bool_fDescriptorAccess_const_RF_t", "std::function< bool (DescriptorAccess const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fDescriptorLogicalLocation_const_RF_t = {"_p_std__functionT_bool_fDescriptorLogicalLocation_const_RF_t", "std::function< bool (DescriptorLogicalLocation const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fDescriptorRange_const_RF_t = {"_p_std__functionT_bool_fDescriptorRange_const_RF_t", "std::function< bool (DescriptorRange const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fDescriptorStoreDescription_const_RF_t = {"_p_std__functionT_bool_fDescriptorStoreDescription_const_RF_t", "std::function< bool (DescriptorStoreDescription const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fDescriptor_const_RF_t = {"_p_std__functionT_bool_fDescriptor_const_RF_t", "std::function< bool (Descriptor const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fEnvironmentModification_const_RF_t = {"_p_std__functionT_bool_fEnvironmentModification_const_RF_t", "std::function< bool (EnvironmentModification const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fEventUsage_const_RF_t = {"_p_std__functionT_bool_fEventUsage_const_RF_t", "std::function< bool (EventUsage const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fF_t = {"_p_std__functionT_bool_fF_t", "RENDERDOC_KillCallback *|std::function< bool () > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fFloatVector_const_RF_t = {"_p_std__functionT_bool_fFloatVector_const_RF_t", "std::function< bool (FloatVector const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fGLPipe__TextureCompleteness_const_RF_t = {"_p_std__functionT_bool_fGLPipe__TextureCompleteness_const_RF_t", "std::function< bool (GLPipe::TextureCompleteness const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fGLPipe__VertexAttribute_const_RF_t = {"_p_std__functionT_bool_fGLPipe__VertexAttribute_const_RF_t", "std::function< bool (GLPipe::VertexAttribute const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fGLPipe__VertexBuffer_const_RF_t = {"_p_std__functionT_bool_fGLPipe__VertexBuffer_const_RF_t", "std::function< bool (GLPipe::VertexBuffer const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fGPUCounter_const_RF_t = {"_p_std__functionT_bool_fGPUCounter_const_RF_t", "std::function< bool (enum GPUCounter const &) > *|std::function< bool (GPUCounter const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fGPUDevice_const_RF_t = {"_p_std__functionT_bool_fGPUDevice_const_RF_t", "std::function< bool (GPUDevice const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fGraphicsAPI_const_RF_t = {"_p_std__functionT_bool_fGraphicsAPI_const_RF_t", "std::function< bool (enum GraphicsAPI const &) > *|std::function< bool (GraphicsAPI const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fInstructionSourceInfo_const_RF_t = {"_p_std__functionT_bool_fInstructionSourceInfo_const_RF_t", "std::function< bool (InstructionSourceInfo const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fLineColumnInfo_const_RF_t = {"_p_std__functionT_bool_fLineColumnInfo_const_RF_t", "std::function< bool (LineColumnInfo const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fMeshletSize_const_RF_t = {"_p_std__functionT_bool_fMeshletSize_const_RF_t", "std::function< bool (MeshletSize const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fOffset_const_RF_t = {"_p_std__functionT_bool_fOffset_const_RF_t", "std::function< bool (Offset const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fPathEntry_const_RF_t = {"_p_std__functionT_bool_fPathEntry_const_RF_t", "std::function< bool (PathEntry const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fPixelModification_const_RF_t = {"_p_std__functionT_bool_fPixelModification_const_RF_t", "std::function< bool (PixelModification const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fResourceBindStats_const_RF_t = {"_p_std__functionT_bool_fResourceBindStats_const_RF_t", "std::function< bool (ResourceBindStats const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fResourceDescription_const_RF_t = {"_p_std__functionT_bool_fResourceDescription_const_RF_t", "std::function< bool (ResourceDescription const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fResourceId_const_RF_t = {"_p_std__functionT_bool_fResourceId_const_RF_t", "std::function< bool (ResourceId const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fSamplerBindStats_const_RF_t = {"_p_std__functionT_bool_fSamplerBindStats_const_RF_t", "std::function< bool (SamplerBindStats const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fSamplerDescriptor_const_RF_t = {"_p_std__functionT_bool_fSamplerDescriptor_const_RF_t", "std::function< bool (SamplerDescriptor const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fScissor_const_RF_t = {"_p_std__functionT_bool_fScissor_const_RF_t", "std::function< bool (Scissor const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderChangeStats_const_RF_t = {"_p_std__functionT_bool_fShaderChangeStats_const_RF_t", "std::function< bool (ShaderChangeStats const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderCompileFlag_const_RF_t = {"_p_std__functionT_bool_fShaderCompileFlag_const_RF_t", "std::function< bool (ShaderCompileFlag const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderConstantType_const_RF_t = {"_p_std__functionT_bool_fShaderConstantType_const_RF_t", "std::function< bool (ShaderConstantType const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderConstant_const_RF_t = {"_p_std__functionT_bool_fShaderConstant_const_RF_t", "std::function< bool (ShaderConstant const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderDebugState_const_RF_t = {"_p_std__functionT_bool_fShaderDebugState_const_RF_t", "std::function< bool (ShaderDebugState const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderEncoding_const_RF_t = {"_p_std__functionT_bool_fShaderEncoding_const_RF_t", "std::function< bool (enum ShaderEncoding const &) > *|std::function< bool (ShaderEncoding const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderEntryPoint_const_RF_t = {"_p_std__functionT_bool_fShaderEntryPoint_const_RF_t", "std::function< bool (ShaderEntryPoint const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderMessage_const_RF_t = {"_p_std__functionT_bool_fShaderMessage_const_RF_t", "std::function< bool (ShaderMessage const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderResource_const_RF_t = {"_p_std__functionT_bool_fShaderResource_const_RF_t", "std::function< bool (ShaderResource const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderSampler_const_RF_t = {"_p_std__functionT_bool_fShaderSampler_const_RF_t", "std::function< bool (ShaderSampler const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderSourceFile_const_RF_t = {"_p_std__functionT_bool_fShaderSourceFile_const_RF_t", "std::function< bool (ShaderSourceFile const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderSourcePrefix_const_RF_t = {"_p_std__functionT_bool_fShaderSourcePrefix_const_RF_t", "std::function< bool (ShaderSourcePrefix const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderVariableChange_const_RF_t = {"_p_std__functionT_bool_fShaderVariableChange_const_RF_t", "std::function< bool (ShaderVariableChange const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fShaderVariable_const_RF_t = {"_p_std__functionT_bool_fShaderVariable_const_RF_t", "std::function< bool (ShaderVariable const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fSigParameter_const_RF_t = {"_p_std__functionT_bool_fSigParameter_const_RF_t", "std::function< bool (SigParameter const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fSourceVariableMapping_const_RF_t = {"_p_std__functionT_bool_fSourceVariableMapping_const_RF_t", "std::function< bool (SourceVariableMapping const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fTaskGroupSize_const_RF_t = {"_p_std__functionT_bool_fTaskGroupSize_const_RF_t", "std::function< bool (TaskGroupSize const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fTextureDescription_const_RF_t = {"_p_std__functionT_bool_fTextureDescription_const_RF_t", "std::function< bool (TextureDescription const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fUsedDescriptor_const_RF_t = {"_p_std__functionT_bool_fUsedDescriptor_const_RF_t", "std::function< bool (UsedDescriptor const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fVKPipe__DescriptorBuffer_const_RF_t = {"_p_std__functionT_bool_fVKPipe__DescriptorBuffer_const_RF_t", "std::function< bool (VKPipe::DescriptorBuffer const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fVKPipe__DescriptorSet_const_RF_t = {"_p_std__functionT_bool_fVKPipe__DescriptorSet_const_RF_t", "std::function< bool (VKPipe::DescriptorSet const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fVKPipe__DynamicOffset_const_RF_t = {"_p_std__functionT_bool_fVKPipe__DynamicOffset_const_RF_t", "std::function< bool (VKPipe::DynamicOffset const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fVKPipe__ImageData_const_RF_t = {"_p_std__functionT_bool_fVKPipe__ImageData_const_RF_t", "std::function< bool (VKPipe::ImageData const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fVKPipe__ImageLayout_const_RF_t = {"_p_std__functionT_bool_fVKPipe__ImageLayout_const_RF_t", "std::function< bool (VKPipe::ImageLayout const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fVKPipe__RenderArea_const_RF_t = {"_p_std__functionT_bool_fVKPipe__RenderArea_const_RF_t", "std::function< bool (VKPipe::RenderArea const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fVKPipe__VertexAttribute_const_RF_t = {"_p_std__functionT_bool_fVKPipe__VertexAttribute_const_RF_t", "std::function< bool (VKPipe::VertexAttribute const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fVKPipe__VertexBinding_const_RF_t = {"_p_std__functionT_bool_fVKPipe__VertexBinding_const_RF_t", "std::function< bool (VKPipe::VertexBinding const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fVKPipe__VertexBuffer_const_RF_t = {"_p_std__functionT_bool_fVKPipe__VertexBuffer_const_RF_t", "std::function< bool (VKPipe::VertexBuffer const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fVKPipe__ViewportScissor_const_RF_t = {"_p_std__functionT_bool_fVKPipe__ViewportScissor_const_RF_t", "std::function< bool (VKPipe::ViewportScissor const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fVKPipe__XFBBuffer_const_RF_t = {"_p_std__functionT_bool_fVKPipe__XFBBuffer_const_RF_t", "std::function< bool (VKPipe::XFBBuffer const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fVertexInputAttribute_const_RF_t = {"_p_std__functionT_bool_fVertexInputAttribute_const_RF_t", "std::function< bool (VertexInputAttribute const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fViewport_const_RF_t = {"_p_std__functionT_bool_fViewport_const_RF_t", "std::function< bool (Viewport const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fWindowingSystem_const_RF_t = {"_p_std__functionT_bool_fWindowingSystem_const_RF_t", "std::function< bool (enum WindowingSystem const &) > *|std::function< bool (WindowingSystem const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_ffloat_const_RF_t = {"_p_std__functionT_bool_ffloat_const_RF_t", "std::function< bool (float const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fint_const_RF_t = {"_p_std__functionT_bool_fint_const_RF_t", "std::function< bool (int const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_frdcstr_const_RF_t = {"_p_std__functionT_bool_frdcstr_const_RF_t", "std::function< bool (rdcstr const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_funsigned_int_const_RF_t = {"_p_std__functionT_bool_funsigned_int_const_RF_t", "std::function< bool (unsigned int const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_funsigned_long_const_RF_t = {"_p_std__functionT_bool_funsigned_long_const_RF_t", "std::function< bool (unsigned long const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_void_ffloatF_t = {"_p_std__functionT_void_ffloatF_t", "RENDERDOC_ProgressCallback *|std::function< void (float) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uint_least32_t *|uint32_t *|unsigned int *|xcb_window_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "uintptr_t *|uint_least64_t *|uint_fast32_t *|uint_fast64_t *|uint64_t *|unsigned long *|uint_fast16_t *|uintmax_t *|Drawable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_wl_display = {"_p_wl_display", "wl_display *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_wl_surface = {"_p_wl_surface", "wl_surface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xcb_connection_t = {"_p_xcb_connection_t", "xcb_connection_t *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_ANativeWindow,
  &_swigt__p_APIEvent,
  &_swigt__p_APIProperties,
  &_swigt__p_APIUseData,
  &_swigt__p_ActionDescription,
  &_swigt__p_ActionFlags,
  &_swigt__p_AddressMode,
  &_swigt__p_AlphaMapping,
  &_swigt__p_AndroidFlags,
  &_swigt__p_AxisMapping,
  &_swigt__p_BindType,
  &_swigt__p_BlendEquation,
  &_swigt__p_BlendMultiplier,
  &_swigt__p_BlendOperation,
  &_swigt__p_BlendStats,
  &_swigt__p_BoundVBuffer,
  &_swigt__p_BucketRecordType,
  &_swigt__p_BufferCategory,
  &_swigt__p_BufferDescription,
  &_swigt__p_BusyData,
  &_swigt__p_CameraType,
  &_swigt__p_CaptureFileFormat,
  &_swigt__p_CaptureOptions,
  &_swigt__p_ChromaSampleLocation,
  &_swigt__p_ColorBlend,
  &_swigt__p_CompType,
  &_swigt__p_CompareFunction,
  &_swigt__p_ConservativeRaster,
  &_swigt__p_ConstantBindStats,
  &_swigt__p_ConstantBlock,
  &_swigt__p_CounterDescription,
  &_swigt__p_CounterResult,
  &_swigt__p_CounterUnit,
  &_swigt__p_CounterValue,
  &_swigt__p_CullMode,
  &_swigt__p_D3D11Pipe__BlendState,
  &_swigt__p_D3D11Pipe__DepthStencilState,
  &_swigt__p_D3D11Pipe__IndexBuffer,
  &_swigt__p_D3D11Pipe__InputAssembly,
  &_swigt__p_D3D11Pipe__Layout,
  &_swigt__p_D3D11Pipe__OutputMerger,
  &_swigt__p_D3D11Pipe__Predication,
  &_swigt__p_D3D11Pipe__Rasterizer,
  &_swigt__p_D3D11Pipe__RasterizerState,
  &_swigt__p_D3D11Pipe__Shader,
  &_swigt__p_D3D11Pipe__State,
  &_swigt__p_D3D11Pipe__StreamOut,
  &_swigt__p_D3D11Pipe__StreamOutBind,
  &_swigt__p_D3D11Pipe__VertexBuffer,
  &_swigt__p_D3D12Pipe__BlendState,
  &_swigt__p_D3D12Pipe__DepthStencilState,
  &_swigt__p_D3D12Pipe__IndexBuffer,
  &_swigt__p_D3D12Pipe__InputAssembly,
  &_swigt__p_D3D12Pipe__Layout,
  &_swigt__p_D3D12Pipe__OM,
  &_swigt__p_D3D12Pipe__Predication,
  &_swigt__p_D3D12Pipe__Rasterizer,
  &_swigt__p_D3D12Pipe__RasterizerState,
  &_swigt__p_D3D12Pipe__ResourceData,
  &_swigt__p_D3D12Pipe__ResourceState,
  &_swigt__p_D3D12Pipe__RootParam,
  &_swigt__p_D3D12Pipe__RootSignature,
  &_swigt__p_D3D12Pipe__RootTableRange,
  &_swigt__p_D3D12Pipe__Shader,
  &_swigt__p_D3D12Pipe__State,
  &_swigt__p_D3D12Pipe__StaticSampler,
  &_swigt__p_D3D12Pipe__StreamOut,
  &_swigt__p_D3D12Pipe__StreamOutBind,
  &_swigt__p_D3D12Pipe__VertexBuffer,
  &_swigt__p_DebugMessage,
  &_swigt__p_DebugOverlay,
  &_swigt__p_DebugPixelInputs,
  &_swigt__p_DebugVariableReference,
  &_swigt__p_DebugVariableType,
  &_swigt__p_DepthStencilStats,
  &_swigt__p_DepthTestState,
  &_swigt__p_Descriptor,
  &_swigt__p_DescriptorAccess,
  &_swigt__p_DescriptorCategory,
  &_swigt__p_DescriptorFlags,
  &_swigt__p_DescriptorLogicalLocation,
  &_swigt__p_DescriptorRange,
  &_swigt__p_DescriptorStoreDescription,
  &_swigt__p_DescriptorType,
  &_swigt__p_DispatchStats,
  &_swigt__p_DrawcallStats,
  &_swigt__p_DriverInformation,
  &_swigt__p_EnvMod,
  &_swigt__p_EnvSep,
  &_swigt__p_EnvironmentModification,
  &_swigt__p_EventUsage,
  &_swigt__p_ExecuteResult,
  &_swigt__p_FileType,
  &_swigt__p_FillMode,
  &_swigt__p_FilterFunction,
  &_swigt__p_FilterMode,
  &_swigt__p_FloatVector,
  &_swigt__p_FrameDescription,
  &_swigt__p_FrameStatistics,
  &_swigt__p_GLPipe__BlendState,
  &_swigt__p_GLPipe__DepthState,
  &_swigt__p_GLPipe__FBO,
  &_swigt__p_GLPipe__Feedback,
  &_swigt__p_GLPipe__FixedVertexProcessing,
  &_swigt__p_GLPipe__FrameBuffer,
  &_swigt__p_GLPipe__Hints,
  &_swigt__p_GLPipe__Rasterizer,
  &_swigt__p_GLPipe__RasterizerState,
  &_swigt__p_GLPipe__Shader,
  &_swigt__p_GLPipe__State,
  &_swigt__p_GLPipe__StencilState,
  &_swigt__p_GLPipe__TextureCompleteness,
  &_swigt__p_GLPipe__VertexAttribute,
  &_swigt__p_GLPipe__VertexBuffer,
  &_swigt__p_GLPipe__VertexInput,
  &_swigt__p_GPUCounter,
  &_swigt__p_GPUDevice,
  &_swigt__p_GPUVendor,
  &_swigt__p_GlobalEnvironment,
  &_swigt__p_GraphicsAPI,
  &_swigt__p_HWND__,
  &_swigt__p_ICamera,
  &_swigt__p_ICaptureAccess,
  &_swigt__p_ICaptureFile,
  &_swigt__p_IDeviceProtocolController,
  &_swigt__p_IRemoteServer,
  &_swigt__p_IReplayController,
  &_swigt__p_IReplayOutput,
  &_swigt__p_ITargetControl,
  &_swigt__p_IndexBindStats,
  &_swigt__p_InstructionSourceInfo,
  &_swigt__p_KnownShaderTool,
  &_swigt__p_LayoutBindStats,
  &_swigt__p_LineColumnInfo,
  &_swigt__p_LineRaster,
  &_swigt__p_LogType,
  &_swigt__p_LogicOperation,
  &_swigt__p_MeshDataStage,
  &_swigt__p_MeshDisplay,
  &_swigt__p_MeshFormat,
  &_swigt__p_MeshletSize,
  &_swigt__p_MessageCategory,
  &_swigt__p_MessageSeverity,
  &_swigt__p_MessageSource,
  &_swigt__p_ModificationValue,
  &_swigt__p_NewCaptureData,
  &_swigt__p_NewChildData,
  &_swigt__p_Offset,
  &_swigt__p_OutputTargetStats,
  &_swigt__p_PathEntry,
  &_swigt__p_PathProperty,
  &_swigt__p_PipeState,
  &_swigt__p_PixelModification,
  &_swigt__p_PixelValue,
  &_swigt__p_PointerVal,
  &_swigt__p_QualityHint,
  &_swigt__p_RasterState,
  &_swigt__p_RasterizationStats,
  &_swigt__p_ReplayOptimisationLevel,
  &_swigt__p_ReplayOptions,
  &_swigt__p_ReplayOutputType,
  &_swigt__p_ReplaySupport,
  &_swigt__p_ResourceBindStats,
  &_swigt__p_ResourceDescription,
  &_swigt__p_ResourceFormat,
  &_swigt__p_ResourceFormatType,
  &_swigt__p_ResourceId,
  &_swigt__p_ResourceType,
  &_swigt__p_ResourceUpdateStats,
  &_swigt__p_ResourceUsage,
  &_swigt__p_ResultCode,
  &_swigt__p_ResultDetails,
  &_swigt__p_SDBasic,
  &_swigt__p_SDChunk,
  &_swigt__p_SDChunkFlags,
  &_swigt__p_SDChunkMetaData,
  &_swigt__p_SDFile,
  &_swigt__p_SDObject,
  &_swigt__p_SDObjectData,
  &_swigt__p_SDObjectPODData,
  &_swigt__p_SDType,
  &_swigt__p_SDTypeFlags,
  &_swigt__p_SamplerBindStats,
  &_swigt__p_SamplerDescriptor,
  &_swigt__p_Scissor,
  &_swigt__p_SectionFlags,
  &_swigt__p_SectionProperties,
  &_swigt__p_SectionType,
  &_swigt__p_ShaderBindIndex,
  &_swigt__p_ShaderBuiltin,
  &_swigt__p_ShaderChangeStats,
  &_swigt__p_ShaderCompileFlag,
  &_swigt__p_ShaderCompileFlags,
  &_swigt__p_ShaderComputeMessageLocation,
  &_swigt__p_ShaderConstant,
  &_swigt__p_ShaderConstantType,
  &_swigt__p_ShaderDebugInfo,
  &_swigt__p_ShaderDebugState,
  &_swigt__p_ShaderDebugTrace,
  &_swigt__p_ShaderDebugger,
  &_swigt__p_ShaderDirectAccess,
  &_swigt__p_ShaderEncoding,
  &_swigt__p_ShaderEntryPoint,
  &_swigt__p_ShaderEvents,
  &_swigt__p_ShaderGeometryMessageLocation,
  &_swigt__p_ShaderMeshMessageLocation,
  &_swigt__p_ShaderMessage,
  &_swigt__p_ShaderMessageLocation,
  &_swigt__p_ShaderPixelMessageLocation,
  &_swigt__p_ShaderReflection,
  &_swigt__p_ShaderResource,
  &_swigt__p_ShaderSampler,
  &_swigt__p_ShaderSourceFile,
  &_swigt__p_ShaderSourcePrefix,
  &_swigt__p_ShaderStage,
  &_swigt__p_ShaderStageMask,
  &_swigt__p_ShaderValue,
  &_swigt__p_ShaderVariable,
  &_swigt__p_ShaderVariableChange,
  &_swigt__p_ShaderVariableFlags,
  &_swigt__p_ShaderVertexMessageLocation,
  &_swigt__p_ShadingRateCombiner,
  &_swigt__p_SigParameter,
  &_swigt__p_SourceVariableMapping,
  &_swigt__p_StencilFace,
  &_swigt__p_StencilOperation,
  &_swigt__p_StructuredBufferList,
  &_swigt__p_StructuredChunkList,
  &_swigt__p_StructuredObjectList,
  &_swigt__p_Subresource,
  &_swigt__p_SwigPyObject,
  &_swigt__p_TargetControlMessage,
  &_swigt__p_TargetControlMessageType,
  &_swigt__p_TaskGroupSize,
  &_swigt__p_TextureCategory,
  &_swigt__p_TextureComponentMapping,
  &_swigt__p_TextureDescription,
  &_swigt__p_TextureDisplay,
  &_swigt__p_TextureFilter,
  &_swigt__p_TextureSampleMapping,
  &_swigt__p_TextureSave,
  &_swigt__p_TextureSliceMapping,
  &_swigt__p_TextureSwizzle,
  &_swigt__p_TextureSwizzle4,
  &_swigt__p_TextureType,
  &_swigt__p_Thumbnail,
  &_swigt__p_Topology,
  &_swigt__p_UsedDescriptor,
  &_swigt__p_Uuid,
  &_swigt__p_VKPipe__ColorBlendState,
  &_swigt__p_VKPipe__ConditionalRendering,
  &_swigt__p_VKPipe__CurrentPass,
  &_swigt__p_VKPipe__DepthStencil,
  &_swigt__p_VKPipe__DescriptorBuffer,
  &_swigt__p_VKPipe__DescriptorSet,
  &_swigt__p_VKPipe__DynamicOffset,
  &_swigt__p_VKPipe__Framebuffer,
  &_swigt__p_VKPipe__ImageData,
  &_swigt__p_VKPipe__ImageLayout,
  &_swigt__p_VKPipe__IndexBuffer,
  &_swigt__p_VKPipe__InputAssembly,
  &_swigt__p_VKPipe__MultiSample,
  &_swigt__p_VKPipe__Pipeline,
  &_swigt__p_VKPipe__Rasterizer,
  &_swigt__p_VKPipe__RenderArea,
  &_swigt__p_VKPipe__RenderPass,
  &_swigt__p_VKPipe__SampleLocations,
  &_swigt__p_VKPipe__Shader,
  &_swigt__p_VKPipe__State,
  &_swigt__p_VKPipe__Tessellation,
  &_swigt__p_VKPipe__TransformFeedback,
  &_swigt__p_VKPipe__VertexAttribute,
  &_swigt__p_VKPipe__VertexBinding,
  &_swigt__p_VKPipe__VertexBuffer,
  &_swigt__p_VKPipe__VertexInput,
  &_swigt__p_VKPipe__ViewState,
  &_swigt__p_VKPipe__ViewportScissor,
  &_swigt__p_VKPipe__XFBBuffer,
  &_swigt__p_VarType,
  &_swigt__p_VertexBindStats,
  &_swigt__p_VertexInputAttribute,
  &_swigt__p_Viewport,
  &_swigt__p_Visualisation,
  &_swigt__p_VulkanLayerFlags,
  &_swigt__p_VulkanLayerRegistrationInfo,
  &_swigt__p_WindowingData,
  &_swigt__p_WindowingSystem,
  &_swigt__p_YcbcrConversion,
  &_swigt__p_YcbcrRange,
  &_swigt__p__XDisplay,
  &_swigt__p_bytebuf,
  &_swigt__p_char,
  &_swigt__p_int,
  &_swigt__p_long,
  &_swigt__p_p_IRemoteServer,
  &_swigt__p_rdcarrayT_APIEvent_t,
  &_swigt__p_rdcarrayT_ActionDescription_t,
  &_swigt__p_rdcarrayT_BoundVBuffer_t,
  &_swigt__p_rdcarrayT_BufferDescription_t,
  &_swigt__p_rdcarrayT_CaptureFileFormat_t,
  &_swigt__p_rdcarrayT_ColorBlend_t,
  &_swigt__p_rdcarrayT_ConstantBindStats_t,
  &_swigt__p_rdcarrayT_ConstantBlock_t,
  &_swigt__p_rdcarrayT_CounterResult_t,
  &_swigt__p_rdcarrayT_D3D11Pipe__Layout_t,
  &_swigt__p_rdcarrayT_D3D11Pipe__StreamOutBind_t,
  &_swigt__p_rdcarrayT_D3D11Pipe__VertexBuffer_t,
  &_swigt__p_rdcarrayT_D3D12Pipe__Layout_t,
  &_swigt__p_rdcarrayT_D3D12Pipe__ResourceData_t,
  &_swigt__p_rdcarrayT_D3D12Pipe__ResourceState_t,
  &_swigt__p_rdcarrayT_D3D12Pipe__RootParam_t,
  &_swigt__p_rdcarrayT_D3D12Pipe__RootTableRange_t,
  &_swigt__p_rdcarrayT_D3D12Pipe__StaticSampler_t,
  &_swigt__p_rdcarrayT_D3D12Pipe__StreamOutBind_t,
  &_swigt__p_rdcarrayT_D3D12Pipe__VertexBuffer_t,
  &_swigt__p_rdcarrayT_DebugMessage_t,
  &_swigt__p_rdcarrayT_DebugVariableReference_t,
  &_swigt__p_rdcarrayT_DescriptorAccess_t,
  &_swigt__p_rdcarrayT_DescriptorLogicalLocation_t,
  &_swigt__p_rdcarrayT_DescriptorRange_t,
  &_swigt__p_rdcarrayT_DescriptorStoreDescription_t,
  &_swigt__p_rdcarrayT_Descriptor_t,
  &_swigt__p_rdcarrayT_EnvironmentModification_t,
  &_swigt__p_rdcarrayT_EventUsage_t,
  &_swigt__p_rdcarrayT_FloatVector_t,
  &_swigt__p_rdcarrayT_GLPipe__TextureCompleteness_t,
  &_swigt__p_rdcarrayT_GLPipe__VertexAttribute_t,
  &_swigt__p_rdcarrayT_GLPipe__VertexBuffer_t,
  &_swigt__p_rdcarrayT_GPUCounter_t,
  &_swigt__p_rdcarrayT_GPUDevice_t,
  &_swigt__p_rdcarrayT_GraphicsAPI_t,
  &_swigt__p_rdcarrayT_InstructionSourceInfo_t,
  &_swigt__p_rdcarrayT_LineColumnInfo_t,
  &_swigt__p_rdcarrayT_MeshletSize_t,
  &_swigt__p_rdcarrayT_Offset_t,
  &_swigt__p_rdcarrayT_PathEntry_t,
  &_swigt__p_rdcarrayT_PixelModification_t,
  &_swigt__p_rdcarrayT_ResourceBindStats_t,
  &_swigt__p_rdcarrayT_ResourceDescription_t,
  &_swigt__p_rdcarrayT_ResourceId_t,
  &_swigt__p_rdcarrayT_SamplerBindStats_t,
  &_swigt__p_rdcarrayT_SamplerDescriptor_t,
  &_swigt__p_rdcarrayT_Scissor_t,
  &_swigt__p_rdcarrayT_ShaderChangeStats_t,
  &_swigt__p_rdcarrayT_ShaderCompileFlag_t,
  &_swigt__p_rdcarrayT_ShaderConstantType_t,
  &_swigt__p_rdcarrayT_ShaderConstant_t,
  &_swigt__p_rdcarrayT_ShaderDebugState_t,
  &_swigt__p_rdcarrayT_ShaderEncoding_t,
  &_swigt__p_rdcarrayT_ShaderEntryPoint_t,
  &_swigt__p_rdcarrayT_ShaderMessage_t,
  &_swigt__p_rdcarrayT_ShaderResource_t,
  &_swigt__p_rdcarrayT_ShaderSampler_t,
  &_swigt__p_rdcarrayT_ShaderSourceFile_t,
  &_swigt__p_rdcarrayT_ShaderSourcePrefix_t,
  &_swigt__p_rdcarrayT_ShaderVariableChange_t,
  &_swigt__p_rdcarrayT_ShaderVariable_t,
  &_swigt__p_rdcarrayT_SigParameter_t,
  &_swigt__p_rdcarrayT_SourceVariableMapping_t,
  &_swigt__p_rdcarrayT_TaskGroupSize_t,
  &_swigt__p_rdcarrayT_TextureDescription_t,
  &_swigt__p_rdcarrayT_UsedDescriptor_t,
  &_swigt__p_rdcarrayT_VKPipe__DescriptorBuffer_t,
  &_swigt__p_rdcarrayT_VKPipe__DescriptorSet_t,
  &_swigt__p_rdcarrayT_VKPipe__DynamicOffset_t,
  &_swigt__p_rdcarrayT_VKPipe__ImageData_t,
  &_swigt__p_rdcarrayT_VKPipe__ImageLayout_t,
  &_swigt__p_rdcarrayT_VKPipe__RenderArea_t,
  &_swigt__p_rdcarrayT_VKPipe__VertexAttribute_t,
  &_swigt__p_rdcarrayT_VKPipe__VertexBinding_t,
  &_swigt__p_rdcarrayT_VKPipe__VertexBuffer_t,
  &_swigt__p_rdcarrayT_VKPipe__ViewportScissor_t,
  &_swigt__p_rdcarrayT_VKPipe__XFBBuffer_t,
  &_swigt__p_rdcarrayT_VertexInputAttribute_t,
  &_swigt__p_rdcarrayT_Viewport_t,
  &_swigt__p_rdcarrayT_WindowingSystem_t,
  &_swigt__p_rdcarrayT_float_t,
  &_swigt__p_rdcarrayT_int_t,
  &_swigt__p_rdcarrayT_rdcstr_t,
  &_swigt__p_rdcarrayT_unsigned_int_t,
  &_swigt__p_rdcarrayT_unsigned_long_t,
  &_swigt__p_rdcfixedarrayT_ResourceId_4_t,
  &_swigt__p_rdcfixedarrayT_ResourceId_8_t,
  &_swigt__p_rdcfixedarrayT_bool_4_t,
  &_swigt__p_rdcfixedarrayT_bool_8_t,
  &_swigt__p_rdcfixedarrayT_double_16_t,
  &_swigt__p_rdcfixedarrayT_float_16_t,
  &_swigt__p_rdcfixedarrayT_float_2_t,
  &_swigt__p_rdcfixedarrayT_float_4_t,
  &_swigt__p_rdcfixedarrayT_int_16_t,
  &_swigt__p_rdcfixedarrayT_int_4_t,
  &_swigt__p_rdcfixedarrayT_long_16_t,
  &_swigt__p_rdcfixedarrayT_rdhalf_16_t,
  &_swigt__p_rdcfixedarrayT_short_16_t,
  &_swigt__p_rdcfixedarrayT_signed_char_16_t,
  &_swigt__p_rdcfixedarrayT_unsigned_char_16_t,
  &_swigt__p_rdcfixedarrayT_unsigned_int_16_t,
  &_swigt__p_rdcfixedarrayT_unsigned_int_3_t,
  &_swigt__p_rdcfixedarrayT_unsigned_int_4_t,
  &_swigt__p_rdcfixedarrayT_unsigned_long_16_t,
  &_swigt__p_rdcfixedarrayT_unsigned_long_4_t,
  &_swigt__p_rdcfixedarrayT_unsigned_short_16_t,
  &_swigt__p_rdcinflexiblestr,
  &_swigt__p_rdcpairT_ShadingRateCombiner_ShadingRateCombiner_t,
  &_swigt__p_rdcpairT_unsigned_int_unsigned_int_t,
  &_swigt__p_rdcstr,
  &_swigt__p_short,
  &_swigt__p_signed_char,
  &_swigt__p_std__functionT_WindowingData_fbool_rdcarrayT_WindowingSystem_t_const_RF_t,
  &_swigt__p_std__functionT_bool_fAPIEvent_const_RF_t,
  &_swigt__p_std__functionT_bool_fActionDescription_const_RF_t,
  &_swigt__p_std__functionT_bool_fBoundVBuffer_const_RF_t,
  &_swigt__p_std__functionT_bool_fBufferDescription_const_RF_t,
  &_swigt__p_std__functionT_bool_fCaptureFileFormat_const_RF_t,
  &_swigt__p_std__functionT_bool_fColorBlend_const_RF_t,
  &_swigt__p_std__functionT_bool_fConstantBindStats_const_RF_t,
  &_swigt__p_std__functionT_bool_fConstantBlock_const_RF_t,
  &_swigt__p_std__functionT_bool_fCounterResult_const_RF_t,
  &_swigt__p_std__functionT_bool_fD3D11Pipe__Layout_const_RF_t,
  &_swigt__p_std__functionT_bool_fD3D11Pipe__StreamOutBind_const_RF_t,
  &_swigt__p_std__functionT_bool_fD3D11Pipe__VertexBuffer_const_RF_t,
  &_swigt__p_std__functionT_bool_fD3D12Pipe__Layout_const_RF_t,
  &_swigt__p_std__functionT_bool_fD3D12Pipe__ResourceData_const_RF_t,
  &_swigt__p_std__functionT_bool_fD3D12Pipe__ResourceState_const_RF_t,
  &_swigt__p_std__functionT_bool_fD3D12Pipe__RootParam_const_RF_t,
  &_swigt__p_std__functionT_bool_fD3D12Pipe__RootTableRange_const_RF_t,
  &_swigt__p_std__functionT_bool_fD3D12Pipe__StaticSampler_const_RF_t,
  &_swigt__p_std__functionT_bool_fD3D12Pipe__StreamOutBind_const_RF_t,
  &_swigt__p_std__functionT_bool_fD3D12Pipe__VertexBuffer_const_RF_t,
  &_swigt__p_std__functionT_bool_fDebugMessage_const_RF_t,
  &_swigt__p_std__functionT_bool_fDebugVariableReference_const_RF_t,
  &_swigt__p_std__functionT_bool_fDescriptorAccess_const_RF_t,
  &_swigt__p_std__functionT_bool_fDescriptorLogicalLocation_const_RF_t,
  &_swigt__p_std__functionT_bool_fDescriptorRange_const_RF_t,
  &_swigt__p_std__functionT_bool_fDescriptorStoreDescription_const_RF_t,
  &_swigt__p_std__functionT_bool_fDescriptor_const_RF_t,
  &_swigt__p_std__functionT_bool_fEnvironmentModification_const_RF_t,
  &_swigt__p_std__functionT_bool_fEventUsage_const_RF_t,
  &_swigt__p_std__functionT_bool_fF_t,
  &_swigt__p_std__functionT_bool_fFloatVector_const_RF_t,
  &_swigt__p_std__functionT_bool_fGLPipe__TextureCompleteness_const_RF_t,
  &_swigt__p_std__functionT_bool_fGLPipe__VertexAttribute_const_RF_t,
  &_swigt__p_std__functionT_bool_fGLPipe__VertexBuffer_const_RF_t,
  &_swigt__p_std__functionT_bool_fGPUCounter_const_RF_t,
  &_swigt__p_std__functionT_bool_fGPUDevice_const_RF_t,
  &_swigt__p_std__functionT_bool_fGraphicsAPI_const_RF_t,
  &_swigt__p_std__functionT_bool_fInstructionSourceInfo_const_RF_t,
  &_swigt__p_std__functionT_bool_fLineColumnInfo_const_RF_t,
  &_swigt__p_std__functionT_bool_fMeshletSize_const_RF_t,
  &_swigt__p_std__functionT_bool_fOffset_const_RF_t,
  &_swigt__p_std__functionT_bool_fPathEntry_const_RF_t,
  &_swigt__p_std__functionT_bool_fPixelModification_const_RF_t,
  &_swigt__p_std__functionT_bool_fResourceBindStats_const_RF_t,
  &_swigt__p_std__functionT_bool_fResourceDescription_const_RF_t,
  &_swigt__p_std__functionT_bool_fResourceId_const_RF_t,
  &_swigt__p_std__functionT_bool_fSamplerBindStats_const_RF_t,
  &_swigt__p_std__functionT_bool_fSamplerDescriptor_const_RF_t,
  &_swigt__p_std__functionT_bool_fScissor_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderChangeStats_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderCompileFlag_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderConstantType_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderConstant_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderDebugState_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderEncoding_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderEntryPoint_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderMessage_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderResource_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderSampler_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderSourceFile_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderSourcePrefix_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderVariableChange_const_RF_t,
  &_swigt__p_std__functionT_bool_fShaderVariable_const_RF_t,
  &_swigt__p_std__functionT_bool_fSigParameter_const_RF_t,
  &_swigt__p_std__functionT_bool_fSourceVariableMapping_const_RF_t,
  &_swigt__p_std__functionT_bool_fTaskGroupSize_const_RF_t,
  &_swigt__p_std__functionT_bool_fTextureDescription_const_RF_t,
  &_swigt__p_std__functionT_bool_fUsedDescriptor_const_RF_t,
  &_swigt__p_std__functionT_bool_fVKPipe__DescriptorBuffer_const_RF_t,
  &_swigt__p_std__functionT_bool_fVKPipe__DescriptorSet_const_RF_t,
  &_swigt__p_std__functionT_bool_fVKPipe__DynamicOffset_const_RF_t,
  &_swigt__p_std__functionT_bool_fVKPipe__ImageData_const_RF_t,
  &_swigt__p_std__functionT_bool_fVKPipe__ImageLayout_const_RF_t,
  &_swigt__p_std__functionT_bool_fVKPipe__RenderArea_const_RF_t,
  &_swigt__p_std__functionT_bool_fVKPipe__VertexAttribute_const_RF_t,
  &_swigt__p_std__functionT_bool_fVKPipe__VertexBinding_const_RF_t,
  &_swigt__p_std__functionT_bool_fVKPipe__VertexBuffer_const_RF_t,
  &_swigt__p_std__functionT_bool_fVKPipe__ViewportScissor_const_RF_t,
  &_swigt__p_std__functionT_bool_fVKPipe__XFBBuffer_const_RF_t,
  &_swigt__p_std__functionT_bool_fVertexInputAttribute_const_RF_t,
  &_swigt__p_std__functionT_bool_fViewport_const_RF_t,
  &_swigt__p_std__functionT_bool_fWindowingSystem_const_RF_t,
  &_swigt__p_std__functionT_bool_ffloat_const_RF_t,
  &_swigt__p_std__functionT_bool_fint_const_RF_t,
  &_swigt__p_std__functionT_bool_frdcstr_const_RF_t,
  &_swigt__p_std__functionT_bool_funsigned_int_const_RF_t,
  &_swigt__p_std__functionT_bool_funsigned_long_const_RF_t,
  &_swigt__p_std__functionT_void_ffloatF_t,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long,
  &_swigt__p_unsigned_short,
  &_swigt__p_value_type,
  &_swigt__p_wl_display,
  &_swigt__p_wl_surface,
  &_swigt__p_xcb_connection_t,
};

static swig_cast_info _swigc__p_ANativeWindow[] = {  {&_swigt__p_ANativeWindow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_APIEvent[] = {  {&_swigt__p_APIEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_APIProperties[] = {  {&_swigt__p_APIProperties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_APIUseData[] = {  {&_swigt__p_APIUseData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ActionDescription[] = {  {&_swigt__p_ActionDescription, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ActionFlags[] = {  {&_swigt__p_ActionFlags, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AddressMode[] = {  {&_swigt__p_AddressMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AlphaMapping[] = {  {&_swigt__p_AlphaMapping, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AndroidFlags[] = {  {&_swigt__p_AndroidFlags, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AxisMapping[] = {  {&_swigt__p_AxisMapping, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BindType[] = {  {&_swigt__p_BindType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlendEquation[] = {  {&_swigt__p_BlendEquation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlendMultiplier[] = {  {&_swigt__p_BlendMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlendOperation[] = {  {&_swigt__p_BlendOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlendStats[] = {  {&_swigt__p_BlendStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BoundVBuffer[] = {  {&_swigt__p_BoundVBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BucketRecordType[] = {  {&_swigt__p_BucketRecordType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BufferCategory[] = {  {&_swigt__p_BufferCategory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BufferDescription[] = {  {&_swigt__p_BufferDescription, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BusyData[] = {  {&_swigt__p_BusyData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraType[] = {  {&_swigt__p_CameraType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CaptureFileFormat[] = {  {&_swigt__p_CaptureFileFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CaptureOptions[] = {  {&_swigt__p_CaptureOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ChromaSampleLocation[] = {  {&_swigt__p_ChromaSampleLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ColorBlend[] = {  {&_swigt__p_ColorBlend, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CompType[] = {  {&_swigt__p_CompType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CompareFunction[] = {  {&_swigt__p_CompareFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConservativeRaster[] = {  {&_swigt__p_ConservativeRaster, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstantBindStats[] = {  {&_swigt__p_ConstantBindStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstantBlock[] = {  {&_swigt__p_ConstantBlock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CounterDescription[] = {  {&_swigt__p_CounterDescription, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CounterResult[] = {  {&_swigt__p_CounterResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CounterUnit[] = {  {&_swigt__p_CounterUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CounterValue[] = {  {&_swigt__p_CounterValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CullMode[] = {  {&_swigt__p_CullMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__BlendState[] = {  {&_swigt__p_D3D11Pipe__BlendState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__DepthStencilState[] = {  {&_swigt__p_D3D11Pipe__DepthStencilState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__IndexBuffer[] = {  {&_swigt__p_D3D11Pipe__IndexBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__InputAssembly[] = {  {&_swigt__p_D3D11Pipe__InputAssembly, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__Layout[] = {  {&_swigt__p_D3D11Pipe__Layout, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__OutputMerger[] = {  {&_swigt__p_D3D11Pipe__OutputMerger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__Predication[] = {  {&_swigt__p_D3D11Pipe__Predication, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__Rasterizer[] = {  {&_swigt__p_D3D11Pipe__Rasterizer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__RasterizerState[] = {  {&_swigt__p_D3D11Pipe__RasterizerState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__Shader[] = {  {&_swigt__p_D3D11Pipe__Shader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__State[] = {  {&_swigt__p_D3D11Pipe__State, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__StreamOut[] = {  {&_swigt__p_D3D11Pipe__StreamOut, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__StreamOutBind[] = {  {&_swigt__p_D3D11Pipe__StreamOutBind, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D11Pipe__VertexBuffer[] = {  {&_swigt__p_D3D11Pipe__VertexBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__BlendState[] = {  {&_swigt__p_D3D12Pipe__BlendState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__DepthStencilState[] = {  {&_swigt__p_D3D12Pipe__DepthStencilState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__IndexBuffer[] = {  {&_swigt__p_D3D12Pipe__IndexBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__InputAssembly[] = {  {&_swigt__p_D3D12Pipe__InputAssembly, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__Layout[] = {  {&_swigt__p_D3D12Pipe__Layout, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__OM[] = {  {&_swigt__p_D3D12Pipe__OM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__Predication[] = {  {&_swigt__p_D3D12Pipe__Predication, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__Rasterizer[] = {  {&_swigt__p_D3D12Pipe__Rasterizer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__RasterizerState[] = {  {&_swigt__p_D3D12Pipe__RasterizerState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__ResourceData[] = {  {&_swigt__p_D3D12Pipe__ResourceData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__ResourceState[] = {  {&_swigt__p_D3D12Pipe__ResourceState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__RootParam[] = {  {&_swigt__p_D3D12Pipe__RootParam, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__RootSignature[] = {  {&_swigt__p_D3D12Pipe__RootSignature, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__RootTableRange[] = {  {&_swigt__p_D3D12Pipe__RootTableRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__Shader[] = {  {&_swigt__p_D3D12Pipe__Shader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__State[] = {  {&_swigt__p_D3D12Pipe__State, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__StaticSampler[] = {  {&_swigt__p_D3D12Pipe__StaticSampler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__StreamOut[] = {  {&_swigt__p_D3D12Pipe__StreamOut, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__StreamOutBind[] = {  {&_swigt__p_D3D12Pipe__StreamOutBind, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_D3D12Pipe__VertexBuffer[] = {  {&_swigt__p_D3D12Pipe__VertexBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DebugMessage[] = {  {&_swigt__p_DebugMessage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DebugOverlay[] = {  {&_swigt__p_DebugOverlay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DebugPixelInputs[] = {  {&_swigt__p_DebugPixelInputs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DebugVariableReference[] = {  {&_swigt__p_DebugVariableReference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DebugVariableType[] = {  {&_swigt__p_DebugVariableType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DepthStencilStats[] = {  {&_swigt__p_DepthStencilStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DepthTestState[] = {  {&_swigt__p_DepthTestState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Descriptor[] = {  {&_swigt__p_Descriptor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DescriptorAccess[] = {  {&_swigt__p_DescriptorAccess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DescriptorCategory[] = {  {&_swigt__p_DescriptorCategory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DescriptorFlags[] = {  {&_swigt__p_DescriptorFlags, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DescriptorLogicalLocation[] = {  {&_swigt__p_DescriptorLogicalLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DescriptorRange[] = {  {&_swigt__p_DescriptorRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DescriptorStoreDescription[] = {  {&_swigt__p_DescriptorStoreDescription, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DescriptorType[] = {  {&_swigt__p_DescriptorType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DispatchStats[] = {  {&_swigt__p_DispatchStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DrawcallStats[] = {  {&_swigt__p_DrawcallStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DriverInformation[] = {  {&_swigt__p_DriverInformation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EnvMod[] = {  {&_swigt__p_EnvMod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EnvSep[] = {  {&_swigt__p_EnvSep, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EnvironmentModification[] = {  {&_swigt__p_EnvironmentModification, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EventUsage[] = {  {&_swigt__p_EventUsage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ExecuteResult[] = {  {&_swigt__p_ExecuteResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FileType[] = {  {&_swigt__p_FileType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FillMode[] = {  {&_swigt__p_FillMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FilterFunction[] = {  {&_swigt__p_FilterFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FilterMode[] = {  {&_swigt__p_FilterMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FloatVector[] = {  {&_swigt__p_FloatVector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FrameDescription[] = {  {&_swigt__p_FrameDescription, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FrameStatistics[] = {  {&_swigt__p_FrameStatistics, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__BlendState[] = {  {&_swigt__p_GLPipe__BlendState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__DepthState[] = {  {&_swigt__p_GLPipe__DepthState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__FBO[] = {  {&_swigt__p_GLPipe__FBO, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__Feedback[] = {  {&_swigt__p_GLPipe__Feedback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__FixedVertexProcessing[] = {  {&_swigt__p_GLPipe__FixedVertexProcessing, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__FrameBuffer[] = {  {&_swigt__p_GLPipe__FrameBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__Hints[] = {  {&_swigt__p_GLPipe__Hints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__Rasterizer[] = {  {&_swigt__p_GLPipe__Rasterizer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__RasterizerState[] = {  {&_swigt__p_GLPipe__RasterizerState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__Shader[] = {  {&_swigt__p_GLPipe__Shader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__State[] = {  {&_swigt__p_GLPipe__State, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__StencilState[] = {  {&_swigt__p_GLPipe__StencilState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__TextureCompleteness[] = {  {&_swigt__p_GLPipe__TextureCompleteness, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__VertexAttribute[] = {  {&_swigt__p_GLPipe__VertexAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__VertexBuffer[] = {  {&_swigt__p_GLPipe__VertexBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLPipe__VertexInput[] = {  {&_swigt__p_GLPipe__VertexInput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GPUCounter[] = {  {&_swigt__p_GPUCounter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GPUDevice[] = {  {&_swigt__p_GPUDevice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GPUVendor[] = {  {&_swigt__p_GPUVendor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GlobalEnvironment[] = {  {&_swigt__p_GlobalEnvironment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GraphicsAPI[] = {  {&_swigt__p_GraphicsAPI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HWND__[] = {  {&_swigt__p_HWND__, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ICamera[] = {  {&_swigt__p_ICamera, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ICaptureAccess[] = {  {&_swigt__p_ICaptureFile, _p_ICaptureFileTo_p_ICaptureAccess, 0, 0},  {&_swigt__p_ICaptureAccess, 0, 0, 0},  {&_swigt__p_IRemoteServer, _p_IRemoteServerTo_p_ICaptureAccess, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ICaptureFile[] = {  {&_swigt__p_ICaptureFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IDeviceProtocolController[] = {  {&_swigt__p_IDeviceProtocolController, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IRemoteServer[] = {  {&_swigt__p_IRemoteServer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IReplayController[] = {  {&_swigt__p_IReplayController, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IReplayOutput[] = {  {&_swigt__p_IReplayOutput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ITargetControl[] = {  {&_swigt__p_ITargetControl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IndexBindStats[] = {  {&_swigt__p_IndexBindStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InstructionSourceInfo[] = {  {&_swigt__p_InstructionSourceInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_KnownShaderTool[] = {  {&_swigt__p_KnownShaderTool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LayoutBindStats[] = {  {&_swigt__p_LayoutBindStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LineColumnInfo[] = {  {&_swigt__p_LineColumnInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LineRaster[] = {  {&_swigt__p_LineRaster, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LogType[] = {  {&_swigt__p_LogType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LogicOperation[] = {  {&_swigt__p_LogicOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MeshDataStage[] = {  {&_swigt__p_MeshDataStage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MeshDisplay[] = {  {&_swigt__p_MeshDisplay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MeshFormat[] = {  {&_swigt__p_MeshFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MeshletSize[] = {  {&_swigt__p_MeshletSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MessageCategory[] = {  {&_swigt__p_MessageCategory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MessageSeverity[] = {  {&_swigt__p_MessageSeverity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MessageSource[] = {  {&_swigt__p_MessageSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ModificationValue[] = {  {&_swigt__p_ModificationValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NewCaptureData[] = {  {&_swigt__p_NewCaptureData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NewChildData[] = {  {&_swigt__p_NewChildData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Offset[] = {  {&_swigt__p_Offset, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OutputTargetStats[] = {  {&_swigt__p_OutputTargetStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PathEntry[] = {  {&_swigt__p_PathEntry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PathProperty[] = {  {&_swigt__p_PathProperty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PipeState[] = {  {&_swigt__p_PipeState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PixelModification[] = {  {&_swigt__p_PixelModification, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PixelValue[] = {  {&_swigt__p_PixelValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PointerVal[] = {  {&_swigt__p_PointerVal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QualityHint[] = {  {&_swigt__p_QualityHint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RasterState[] = {  {&_swigt__p_RasterState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RasterizationStats[] = {  {&_swigt__p_RasterizationStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ReplayOptimisationLevel[] = {  {&_swigt__p_ReplayOptimisationLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ReplayOptions[] = {  {&_swigt__p_ReplayOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ReplayOutputType[] = {  {&_swigt__p_ReplayOutputType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ReplaySupport[] = {  {&_swigt__p_ReplaySupport, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceBindStats[] = {  {&_swigt__p_ResourceBindStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceDescription[] = {  {&_swigt__p_ResourceDescription, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceFormat[] = {  {&_swigt__p_ResourceFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceFormatType[] = {  {&_swigt__p_ResourceFormatType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceId[] = {  {&_swigt__p_ResourceId, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceType[] = {  {&_swigt__p_ResourceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceUpdateStats[] = {  {&_swigt__p_ResourceUpdateStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceUsage[] = {  {&_swigt__p_ResourceUsage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResultCode[] = {  {&_swigt__p_ResultCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResultDetails[] = {  {&_swigt__p_ResultDetails, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SDBasic[] = {  {&_swigt__p_SDBasic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SDChunk[] = {  {&_swigt__p_SDChunk, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SDChunkFlags[] = {  {&_swigt__p_SDChunkFlags, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SDChunkMetaData[] = {  {&_swigt__p_SDChunkMetaData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SDFile[] = {  {&_swigt__p_SDFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SDObject[] = {  {&_swigt__p_SDChunk, _p_SDChunkTo_p_SDObject, 0, 0},  {&_swigt__p_SDObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SDObjectData[] = {  {&_swigt__p_SDObjectData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SDObjectPODData[] = {  {&_swigt__p_SDObjectPODData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SDType[] = {  {&_swigt__p_SDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SDTypeFlags[] = {  {&_swigt__p_SDTypeFlags, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SamplerBindStats[] = {  {&_swigt__p_SamplerBindStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SamplerDescriptor[] = {  {&_swigt__p_SamplerDescriptor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Scissor[] = {  {&_swigt__p_Scissor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SectionFlags[] = {  {&_swigt__p_SectionFlags, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SectionProperties[] = {  {&_swigt__p_SectionProperties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SectionType[] = {  {&_swigt__p_SectionType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderBindIndex[] = {  {&_swigt__p_ShaderBindIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderBuiltin[] = {  {&_swigt__p_ShaderBuiltin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderChangeStats[] = {  {&_swigt__p_ShaderChangeStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderCompileFlag[] = {  {&_swigt__p_ShaderCompileFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderCompileFlags[] = {  {&_swigt__p_ShaderCompileFlags, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderComputeMessageLocation[] = {  {&_swigt__p_ShaderComputeMessageLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderConstant[] = {  {&_swigt__p_ShaderConstant, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderConstantType[] = {  {&_swigt__p_ShaderConstantType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderDebugInfo[] = {  {&_swigt__p_ShaderDebugInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderDebugState[] = {  {&_swigt__p_ShaderDebugState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderDebugTrace[] = {  {&_swigt__p_ShaderDebugTrace, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderDebugger[] = {  {&_swigt__p_ShaderDebugger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderDirectAccess[] = {  {&_swigt__p_ShaderDirectAccess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderEncoding[] = {  {&_swigt__p_ShaderEncoding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderEntryPoint[] = {  {&_swigt__p_ShaderEntryPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderEvents[] = {  {&_swigt__p_ShaderEvents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderGeometryMessageLocation[] = {  {&_swigt__p_ShaderGeometryMessageLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderMeshMessageLocation[] = {  {&_swigt__p_ShaderMeshMessageLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderMessage[] = {  {&_swigt__p_ShaderMessage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderMessageLocation[] = {  {&_swigt__p_ShaderMessageLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderPixelMessageLocation[] = {  {&_swigt__p_ShaderPixelMessageLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderReflection[] = {  {&_swigt__p_ShaderReflection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderResource[] = {  {&_swigt__p_ShaderResource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderSampler[] = {  {&_swigt__p_ShaderSampler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderSourceFile[] = {  {&_swigt__p_ShaderSourceFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderSourcePrefix[] = {  {&_swigt__p_ShaderSourcePrefix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderStage[] = {  {&_swigt__p_ShaderStage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderStageMask[] = {  {&_swigt__p_ShaderStageMask, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderValue[] = {  {&_swigt__p_ShaderValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderVariable[] = {  {&_swigt__p_ShaderVariable, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderVariableChange[] = {  {&_swigt__p_ShaderVariableChange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderVariableFlags[] = {  {&_swigt__p_ShaderVariableFlags, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderVertexMessageLocation[] = {  {&_swigt__p_ShaderVertexMessageLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShadingRateCombiner[] = {  {&_swigt__p_ShadingRateCombiner, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SigParameter[] = {  {&_swigt__p_SigParameter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SourceVariableMapping[] = {  {&_swigt__p_SourceVariableMapping, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StencilFace[] = {  {&_swigt__p_StencilFace, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StencilOperation[] = {  {&_swigt__p_StencilOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StructuredBufferList[] = {  {&_swigt__p_StructuredBufferList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StructuredChunkList[] = {  {&_swigt__p_StructuredChunkList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StructuredObjectList[] = {  {&_swigt__p_StructuredObjectList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Subresource[] = {  {&_swigt__p_Subresource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwigPyObject[] = {  {&_swigt__p_SwigPyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TargetControlMessage[] = {  {&_swigt__p_TargetControlMessage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TargetControlMessageType[] = {  {&_swigt__p_TargetControlMessageType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TaskGroupSize[] = {  {&_swigt__p_TaskGroupSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureCategory[] = {  {&_swigt__p_TextureCategory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureComponentMapping[] = {  {&_swigt__p_TextureComponentMapping, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureDescription[] = {  {&_swigt__p_TextureDescription, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureDisplay[] = {  {&_swigt__p_TextureDisplay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureFilter[] = {  {&_swigt__p_TextureFilter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureSampleMapping[] = {  {&_swigt__p_TextureSampleMapping, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureSave[] = {  {&_swigt__p_TextureSave, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureSliceMapping[] = {  {&_swigt__p_TextureSliceMapping, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureSwizzle[] = {  {&_swigt__p_TextureSwizzle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureSwizzle4[] = {  {&_swigt__p_TextureSwizzle4, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureType[] = {  {&_swigt__p_TextureType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Thumbnail[] = {  {&_swigt__p_Thumbnail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Topology[] = {  {&_swigt__p_Topology, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UsedDescriptor[] = {  {&_swigt__p_UsedDescriptor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Uuid[] = {  {&_swigt__p_Uuid, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__ColorBlendState[] = {  {&_swigt__p_VKPipe__ColorBlendState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__ConditionalRendering[] = {  {&_swigt__p_VKPipe__ConditionalRendering, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__CurrentPass[] = {  {&_swigt__p_VKPipe__CurrentPass, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__DepthStencil[] = {  {&_swigt__p_VKPipe__DepthStencil, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__DescriptorBuffer[] = {  {&_swigt__p_VKPipe__DescriptorBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__DescriptorSet[] = {  {&_swigt__p_VKPipe__DescriptorSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__DynamicOffset[] = {  {&_swigt__p_VKPipe__DynamicOffset, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__Framebuffer[] = {  {&_swigt__p_VKPipe__Framebuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__ImageData[] = {  {&_swigt__p_VKPipe__ImageData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__ImageLayout[] = {  {&_swigt__p_VKPipe__ImageLayout, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__IndexBuffer[] = {  {&_swigt__p_VKPipe__IndexBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__InputAssembly[] = {  {&_swigt__p_VKPipe__InputAssembly, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__MultiSample[] = {  {&_swigt__p_VKPipe__MultiSample, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__Pipeline[] = {  {&_swigt__p_VKPipe__Pipeline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__Rasterizer[] = {  {&_swigt__p_VKPipe__Rasterizer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__RenderArea[] = {  {&_swigt__p_VKPipe__RenderArea, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__RenderPass[] = {  {&_swigt__p_VKPipe__RenderPass, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__SampleLocations[] = {  {&_swigt__p_VKPipe__SampleLocations, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__Shader[] = {  {&_swigt__p_VKPipe__Shader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__State[] = {  {&_swigt__p_VKPipe__State, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__Tessellation[] = {  {&_swigt__p_VKPipe__Tessellation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__TransformFeedback[] = {  {&_swigt__p_VKPipe__TransformFeedback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__VertexAttribute[] = {  {&_swigt__p_VKPipe__VertexAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__VertexBinding[] = {  {&_swigt__p_VKPipe__VertexBinding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__VertexBuffer[] = {  {&_swigt__p_VKPipe__VertexBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__VertexInput[] = {  {&_swigt__p_VKPipe__VertexInput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__ViewState[] = {  {&_swigt__p_VKPipe__ViewState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__ViewportScissor[] = {  {&_swigt__p_VKPipe__ViewportScissor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VKPipe__XFBBuffer[] = {  {&_swigt__p_VKPipe__XFBBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VarType[] = {  {&_swigt__p_VarType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VertexBindStats[] = {  {&_swigt__p_VertexBindStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VertexInputAttribute[] = {  {&_swigt__p_VertexInputAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Viewport[] = {  {&_swigt__p_Viewport, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Visualisation[] = {  {&_swigt__p_Visualisation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VulkanLayerFlags[] = {  {&_swigt__p_VulkanLayerFlags, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VulkanLayerRegistrationInfo[] = {  {&_swigt__p_VulkanLayerRegistrationInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_WindowingData[] = {  {&_swigt__p_WindowingData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_WindowingSystem[] = {  {&_swigt__p_WindowingSystem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YcbcrConversion[] = {  {&_swigt__p_YcbcrConversion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YcbcrRange[] = {  {&_swigt__p_YcbcrRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__XDisplay[] = {  {&_swigt__p__XDisplay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bytebuf[] = {  {&_swigt__p_bytebuf, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_IRemoteServer[] = {  {&_swigt__p_p_IRemoteServer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_APIEvent_t[] = {  {&_swigt__p_rdcarrayT_APIEvent_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ActionDescription_t[] = {  {&_swigt__p_rdcarrayT_ActionDescription_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_BoundVBuffer_t[] = {  {&_swigt__p_rdcarrayT_BoundVBuffer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_BufferDescription_t[] = {  {&_swigt__p_rdcarrayT_BufferDescription_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_CaptureFileFormat_t[] = {  {&_swigt__p_rdcarrayT_CaptureFileFormat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ColorBlend_t[] = {  {&_swigt__p_rdcarrayT_ColorBlend_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ConstantBindStats_t[] = {  {&_swigt__p_rdcarrayT_ConstantBindStats_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ConstantBlock_t[] = {  {&_swigt__p_rdcarrayT_ConstantBlock_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_CounterResult_t[] = {  {&_swigt__p_rdcarrayT_CounterResult_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_D3D11Pipe__Layout_t[] = {  {&_swigt__p_rdcarrayT_D3D11Pipe__Layout_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_D3D11Pipe__StreamOutBind_t[] = {  {&_swigt__p_rdcarrayT_D3D11Pipe__StreamOutBind_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_D3D11Pipe__VertexBuffer_t[] = {  {&_swigt__p_rdcarrayT_D3D11Pipe__VertexBuffer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_D3D12Pipe__Layout_t[] = {  {&_swigt__p_rdcarrayT_D3D12Pipe__Layout_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_D3D12Pipe__ResourceData_t[] = {  {&_swigt__p_rdcarrayT_D3D12Pipe__ResourceData_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_D3D12Pipe__ResourceState_t[] = {  {&_swigt__p_rdcarrayT_D3D12Pipe__ResourceState_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_D3D12Pipe__RootParam_t[] = {  {&_swigt__p_rdcarrayT_D3D12Pipe__RootParam_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_D3D12Pipe__RootTableRange_t[] = {  {&_swigt__p_rdcarrayT_D3D12Pipe__RootTableRange_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_D3D12Pipe__StaticSampler_t[] = {  {&_swigt__p_rdcarrayT_D3D12Pipe__StaticSampler_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_D3D12Pipe__StreamOutBind_t[] = {  {&_swigt__p_rdcarrayT_D3D12Pipe__StreamOutBind_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_D3D12Pipe__VertexBuffer_t[] = {  {&_swigt__p_rdcarrayT_D3D12Pipe__VertexBuffer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_DebugMessage_t[] = {  {&_swigt__p_rdcarrayT_DebugMessage_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_DebugVariableReference_t[] = {  {&_swigt__p_rdcarrayT_DebugVariableReference_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_DescriptorAccess_t[] = {  {&_swigt__p_rdcarrayT_DescriptorAccess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_DescriptorLogicalLocation_t[] = {  {&_swigt__p_rdcarrayT_DescriptorLogicalLocation_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_DescriptorRange_t[] = {  {&_swigt__p_rdcarrayT_DescriptorRange_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_DescriptorStoreDescription_t[] = {  {&_swigt__p_rdcarrayT_DescriptorStoreDescription_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_Descriptor_t[] = {  {&_swigt__p_rdcarrayT_Descriptor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_EnvironmentModification_t[] = {  {&_swigt__p_rdcarrayT_EnvironmentModification_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_EventUsage_t[] = {  {&_swigt__p_rdcarrayT_EventUsage_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_FloatVector_t[] = {  {&_swigt__p_rdcarrayT_FloatVector_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_GLPipe__TextureCompleteness_t[] = {  {&_swigt__p_rdcarrayT_GLPipe__TextureCompleteness_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_GLPipe__VertexAttribute_t[] = {  {&_swigt__p_rdcarrayT_GLPipe__VertexAttribute_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_GLPipe__VertexBuffer_t[] = {  {&_swigt__p_rdcarrayT_GLPipe__VertexBuffer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_GPUCounter_t[] = {  {&_swigt__p_rdcarrayT_GPUCounter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_GPUDevice_t[] = {  {&_swigt__p_rdcarrayT_GPUDevice_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_GraphicsAPI_t[] = {  {&_swigt__p_rdcarrayT_GraphicsAPI_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_InstructionSourceInfo_t[] = {  {&_swigt__p_rdcarrayT_InstructionSourceInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_LineColumnInfo_t[] = {  {&_swigt__p_rdcarrayT_LineColumnInfo_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_MeshletSize_t[] = {  {&_swigt__p_rdcarrayT_MeshletSize_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_Offset_t[] = {  {&_swigt__p_rdcarrayT_Offset_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_PathEntry_t[] = {  {&_swigt__p_rdcarrayT_PathEntry_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_PixelModification_t[] = {  {&_swigt__p_rdcarrayT_PixelModification_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ResourceBindStats_t[] = {  {&_swigt__p_rdcarrayT_ResourceBindStats_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ResourceDescription_t[] = {  {&_swigt__p_rdcarrayT_ResourceDescription_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ResourceId_t[] = {  {&_swigt__p_rdcarrayT_ResourceId_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_SamplerBindStats_t[] = {  {&_swigt__p_rdcarrayT_SamplerBindStats_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_SamplerDescriptor_t[] = {  {&_swigt__p_rdcarrayT_SamplerDescriptor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_Scissor_t[] = {  {&_swigt__p_rdcarrayT_Scissor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderChangeStats_t[] = {  {&_swigt__p_rdcarrayT_ShaderChangeStats_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderCompileFlag_t[] = {  {&_swigt__p_rdcarrayT_ShaderCompileFlag_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderConstantType_t[] = {  {&_swigt__p_rdcarrayT_ShaderConstantType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderConstant_t[] = {  {&_swigt__p_rdcarrayT_ShaderConstant_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderDebugState_t[] = {  {&_swigt__p_rdcarrayT_ShaderDebugState_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderEncoding_t[] = {  {&_swigt__p_rdcarrayT_ShaderEncoding_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderEntryPoint_t[] = {  {&_swigt__p_rdcarrayT_ShaderEntryPoint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderMessage_t[] = {  {&_swigt__p_rdcarrayT_ShaderMessage_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderResource_t[] = {  {&_swigt__p_rdcarrayT_ShaderResource_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderSampler_t[] = {  {&_swigt__p_rdcarrayT_ShaderSampler_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderSourceFile_t[] = {  {&_swigt__p_rdcarrayT_ShaderSourceFile_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderSourcePrefix_t[] = {  {&_swigt__p_rdcarrayT_ShaderSourcePrefix_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderVariableChange_t[] = {  {&_swigt__p_rdcarrayT_ShaderVariableChange_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_ShaderVariable_t[] = {  {&_swigt__p_rdcarrayT_ShaderVariable_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_SigParameter_t[] = {  {&_swigt__p_rdcarrayT_SigParameter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_SourceVariableMapping_t[] = {  {&_swigt__p_rdcarrayT_SourceVariableMapping_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_TaskGroupSize_t[] = {  {&_swigt__p_rdcarrayT_TaskGroupSize_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_TextureDescription_t[] = {  {&_swigt__p_rdcarrayT_TextureDescription_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_UsedDescriptor_t[] = {  {&_swigt__p_rdcarrayT_UsedDescriptor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_VKPipe__DescriptorBuffer_t[] = {  {&_swigt__p_rdcarrayT_VKPipe__DescriptorBuffer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_VKPipe__DescriptorSet_t[] = {  {&_swigt__p_rdcarrayT_VKPipe__DescriptorSet_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_VKPipe__DynamicOffset_t[] = {  {&_swigt__p_rdcarrayT_VKPipe__DynamicOffset_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_VKPipe__ImageData_t[] = {  {&_swigt__p_rdcarrayT_VKPipe__ImageData_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_VKPipe__ImageLayout_t[] = {  {&_swigt__p_rdcarrayT_VKPipe__ImageLayout_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_VKPipe__RenderArea_t[] = {  {&_swigt__p_rdcarrayT_VKPipe__RenderArea_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_VKPipe__VertexAttribute_t[] = {  {&_swigt__p_rdcarrayT_VKPipe__VertexAttribute_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_VKPipe__VertexBinding_t[] = {  {&_swigt__p_rdcarrayT_VKPipe__VertexBinding_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_VKPipe__VertexBuffer_t[] = {  {&_swigt__p_rdcarrayT_VKPipe__VertexBuffer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_VKPipe__ViewportScissor_t[] = {  {&_swigt__p_rdcarrayT_VKPipe__ViewportScissor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_VKPipe__XFBBuffer_t[] = {  {&_swigt__p_rdcarrayT_VKPipe__XFBBuffer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_VertexInputAttribute_t[] = {  {&_swigt__p_rdcarrayT_VertexInputAttribute_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_Viewport_t[] = {  {&_swigt__p_rdcarrayT_Viewport_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_WindowingSystem_t[] = {  {&_swigt__p_rdcarrayT_WindowingSystem_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_float_t[] = {  {&_swigt__p_rdcarrayT_float_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_int_t[] = {  {&_swigt__p_rdcarrayT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_rdcstr_t[] = {  {&_swigt__p_rdcarrayT_rdcstr_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_unsigned_int_t[] = {  {&_swigt__p_rdcarrayT_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcarrayT_unsigned_long_t[] = {  {&_swigt__p_rdcarrayT_unsigned_long_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_ResourceId_4_t[] = {  {&_swigt__p_rdcfixedarrayT_ResourceId_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_ResourceId_8_t[] = {  {&_swigt__p_rdcfixedarrayT_ResourceId_8_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_bool_4_t[] = {  {&_swigt__p_rdcfixedarrayT_bool_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_bool_8_t[] = {  {&_swigt__p_rdcfixedarrayT_bool_8_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_double_16_t[] = {  {&_swigt__p_rdcfixedarrayT_double_16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_float_16_t[] = {  {&_swigt__p_rdcfixedarrayT_float_16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_float_2_t[] = {  {&_swigt__p_rdcfixedarrayT_float_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_float_4_t[] = {  {&_swigt__p_rdcfixedarrayT_float_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_int_16_t[] = {  {&_swigt__p_rdcfixedarrayT_int_16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_int_4_t[] = {  {&_swigt__p_rdcfixedarrayT_int_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_long_16_t[] = {  {&_swigt__p_rdcfixedarrayT_long_16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_rdhalf_16_t[] = {  {&_swigt__p_rdcfixedarrayT_rdhalf_16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_short_16_t[] = {  {&_swigt__p_rdcfixedarrayT_short_16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_signed_char_16_t[] = {  {&_swigt__p_rdcfixedarrayT_signed_char_16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_unsigned_char_16_t[] = {  {&_swigt__p_rdcfixedarrayT_unsigned_char_16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_unsigned_int_16_t[] = {  {&_swigt__p_rdcfixedarrayT_unsigned_int_16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_unsigned_int_3_t[] = {  {&_swigt__p_rdcfixedarrayT_unsigned_int_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_unsigned_int_4_t[] = {  {&_swigt__p_rdcfixedarrayT_unsigned_int_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_unsigned_long_16_t[] = {  {&_swigt__p_rdcfixedarrayT_unsigned_long_16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_unsigned_long_4_t[] = {  {&_swigt__p_rdcfixedarrayT_unsigned_long_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcfixedarrayT_unsigned_short_16_t[] = {  {&_swigt__p_rdcfixedarrayT_unsigned_short_16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcinflexiblestr[] = {  {&_swigt__p_rdcinflexiblestr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcpairT_ShadingRateCombiner_ShadingRateCombiner_t[] = {  {&_swigt__p_rdcpairT_ShadingRateCombiner_ShadingRateCombiner_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcpairT_unsigned_int_unsigned_int_t[] = {  {&_swigt__p_rdcpairT_unsigned_int_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rdcstr[] = {  {&_swigt__p_rdcstr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_WindowingData_fbool_rdcarrayT_WindowingSystem_t_const_RF_t[] = {  {&_swigt__p_std__functionT_WindowingData_fbool_rdcarrayT_WindowingSystem_t_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fAPIEvent_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fAPIEvent_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fActionDescription_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fActionDescription_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fBoundVBuffer_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fBoundVBuffer_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fBufferDescription_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fBufferDescription_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fCaptureFileFormat_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fCaptureFileFormat_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fColorBlend_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fColorBlend_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fConstantBindStats_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fConstantBindStats_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fConstantBlock_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fConstantBlock_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fCounterResult_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fCounterResult_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fD3D11Pipe__Layout_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fD3D11Pipe__Layout_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fD3D11Pipe__StreamOutBind_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fD3D11Pipe__StreamOutBind_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fD3D11Pipe__VertexBuffer_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fD3D11Pipe__VertexBuffer_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fD3D12Pipe__Layout_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fD3D12Pipe__Layout_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fD3D12Pipe__ResourceData_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fD3D12Pipe__ResourceData_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fD3D12Pipe__ResourceState_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fD3D12Pipe__ResourceState_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fD3D12Pipe__RootParam_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fD3D12Pipe__RootParam_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fD3D12Pipe__RootTableRange_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fD3D12Pipe__RootTableRange_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fD3D12Pipe__StaticSampler_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fD3D12Pipe__StaticSampler_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fD3D12Pipe__StreamOutBind_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fD3D12Pipe__StreamOutBind_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fD3D12Pipe__VertexBuffer_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fD3D12Pipe__VertexBuffer_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fDebugMessage_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fDebugMessage_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fDebugVariableReference_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fDebugVariableReference_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fDescriptorAccess_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fDescriptorAccess_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fDescriptorLogicalLocation_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fDescriptorLogicalLocation_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fDescriptorRange_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fDescriptorRange_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fDescriptorStoreDescription_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fDescriptorStoreDescription_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fDescriptor_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fDescriptor_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fEnvironmentModification_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fEnvironmentModification_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fEventUsage_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fEventUsage_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fF_t[] = {  {&_swigt__p_std__functionT_bool_fF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fFloatVector_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fFloatVector_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fGLPipe__TextureCompleteness_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fGLPipe__TextureCompleteness_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fGLPipe__VertexAttribute_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fGLPipe__VertexAttribute_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fGLPipe__VertexBuffer_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fGLPipe__VertexBuffer_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fGPUCounter_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fGPUCounter_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fGPUDevice_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fGPUDevice_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fGraphicsAPI_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fGraphicsAPI_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fInstructionSourceInfo_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fInstructionSourceInfo_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fLineColumnInfo_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fLineColumnInfo_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fMeshletSize_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fMeshletSize_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fOffset_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fOffset_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fPathEntry_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fPathEntry_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fPixelModification_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fPixelModification_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fResourceBindStats_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fResourceBindStats_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fResourceDescription_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fResourceDescription_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fResourceId_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fResourceId_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fSamplerBindStats_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fSamplerBindStats_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fSamplerDescriptor_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fSamplerDescriptor_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fScissor_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fScissor_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderChangeStats_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderChangeStats_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderCompileFlag_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderCompileFlag_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderConstantType_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderConstantType_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderConstant_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderConstant_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderDebugState_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderDebugState_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderEncoding_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderEncoding_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderEntryPoint_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderEntryPoint_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderMessage_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderMessage_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderResource_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderResource_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderSampler_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderSampler_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderSourceFile_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderSourceFile_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderSourcePrefix_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderSourcePrefix_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderVariableChange_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderVariableChange_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fShaderVariable_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fShaderVariable_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fSigParameter_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fSigParameter_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fSourceVariableMapping_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fSourceVariableMapping_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fTaskGroupSize_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fTaskGroupSize_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fTextureDescription_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fTextureDescription_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fUsedDescriptor_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fUsedDescriptor_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fVKPipe__DescriptorBuffer_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fVKPipe__DescriptorBuffer_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fVKPipe__DescriptorSet_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fVKPipe__DescriptorSet_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fVKPipe__DynamicOffset_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fVKPipe__DynamicOffset_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fVKPipe__ImageData_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fVKPipe__ImageData_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fVKPipe__ImageLayout_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fVKPipe__ImageLayout_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fVKPipe__RenderArea_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fVKPipe__RenderArea_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fVKPipe__VertexAttribute_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fVKPipe__VertexAttribute_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fVKPipe__VertexBinding_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fVKPipe__VertexBinding_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fVKPipe__VertexBuffer_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fVKPipe__VertexBuffer_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fVKPipe__ViewportScissor_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fVKPipe__ViewportScissor_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fVKPipe__XFBBuffer_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fVKPipe__XFBBuffer_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fVertexInputAttribute_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fVertexInputAttribute_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fViewport_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fViewport_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fWindowingSystem_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fWindowingSystem_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_ffloat_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_ffloat_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fint_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_fint_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_frdcstr_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_frdcstr_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_funsigned_int_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_funsigned_int_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_funsigned_long_const_RF_t[] = {  {&_swigt__p_std__functionT_bool_funsigned_long_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_void_ffloatF_t[] = {  {&_swigt__p_std__functionT_void_ffloatF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_wl_display[] = {  {&_swigt__p_wl_display, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_wl_surface[] = {  {&_swigt__p_wl_surface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xcb_connection_t[] = {  {&_swigt__p_xcb_connection_t, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_ANativeWindow,
  _swigc__p_APIEvent,
  _swigc__p_APIProperties,
  _swigc__p_APIUseData,
  _swigc__p_ActionDescription,
  _swigc__p_ActionFlags,
  _swigc__p_AddressMode,
  _swigc__p_AlphaMapping,
  _swigc__p_AndroidFlags,
  _swigc__p_AxisMapping,
  _swigc__p_BindType,
  _swigc__p_BlendEquation,
  _swigc__p_BlendMultiplier,
  _swigc__p_BlendOperation,
  _swigc__p_BlendStats,
  _swigc__p_BoundVBuffer,
  _swigc__p_BucketRecordType,
  _swigc__p_BufferCategory,
  _swigc__p_BufferDescription,
  _swigc__p_BusyData,
  _swigc__p_CameraType,
  _swigc__p_CaptureFileFormat,
  _swigc__p_CaptureOptions,
  _swigc__p_ChromaSampleLocation,
  _swigc__p_ColorBlend,
  _swigc__p_CompType,
  _swigc__p_CompareFunction,
  _swigc__p_ConservativeRaster,
  _swigc__p_ConstantBindStats,
  _swigc__p_ConstantBlock,
  _swigc__p_CounterDescription,
  _swigc__p_CounterResult,
  _swigc__p_CounterUnit,
  _swigc__p_CounterValue,
  _swigc__p_CullMode,
  _swigc__p_D3D11Pipe__BlendState,
  _swigc__p_D3D11Pipe__DepthStencilState,
  _swigc__p_D3D11Pipe__IndexBuffer,
  _swigc__p_D3D11Pipe__InputAssembly,
  _swigc__p_D3D11Pipe__Layout,
  _swigc__p_D3D11Pipe__OutputMerger,
  _swigc__p_D3D11Pipe__Predication,
  _swigc__p_D3D11Pipe__Rasterizer,
  _swigc__p_D3D11Pipe__RasterizerState,
  _swigc__p_D3D11Pipe__Shader,
  _swigc__p_D3D11Pipe__State,
  _swigc__p_D3D11Pipe__StreamOut,
  _swigc__p_D3D11Pipe__StreamOutBind,
  _swigc__p_D3D11Pipe__VertexBuffer,
  _swigc__p_D3D12Pipe__BlendState,
  _swigc__p_D3D12Pipe__DepthStencilState,
  _swigc__p_D3D12Pipe__IndexBuffer,
  _swigc__p_D3D12Pipe__InputAssembly,
  _swigc__p_D3D12Pipe__Layout,
  _swigc__p_D3D12Pipe__OM,
  _swigc__p_D3D12Pipe__Predication,
  _swigc__p_D3D12Pipe__Rasterizer,
  _swigc__p_D3D12Pipe__RasterizerState,
  _swigc__p_D3D12Pipe__ResourceData,
  _swigc__p_D3D12Pipe__ResourceState,
  _swigc__p_D3D12Pipe__RootParam,
  _swigc__p_D3D12Pipe__RootSignature,
  _swigc__p_D3D12Pipe__RootTableRange,
  _swigc__p_D3D12Pipe__Shader,
  _swigc__p_D3D12Pipe__State,
  _swigc__p_D3D12Pipe__StaticSampler,
  _swigc__p_D3D12Pipe__StreamOut,
  _swigc__p_D3D12Pipe__StreamOutBind,
  _swigc__p_D3D12Pipe__VertexBuffer,
  _swigc__p_DebugMessage,
  _swigc__p_DebugOverlay,
  _swigc__p_DebugPixelInputs,
  _swigc__p_DebugVariableReference,
  _swigc__p_DebugVariableType,
  _swigc__p_DepthStencilStats,
  _swigc__p_DepthTestState,
  _swigc__p_Descriptor,
  _swigc__p_DescriptorAccess,
  _swigc__p_DescriptorCategory,
  _swigc__p_DescriptorFlags,
  _swigc__p_DescriptorLogicalLocation,
  _swigc__p_DescriptorRange,
  _swigc__p_DescriptorStoreDescription,
  _swigc__p_DescriptorType,
  _swigc__p_DispatchStats,
  _swigc__p_DrawcallStats,
  _swigc__p_DriverInformation,
  _swigc__p_EnvMod,
  _swigc__p_EnvSep,
  _swigc__p_EnvironmentModification,
  _swigc__p_EventUsage,
  _swigc__p_ExecuteResult,
  _swigc__p_FileType,
  _swigc__p_FillMode,
  _swigc__p_FilterFunction,
  _swigc__p_FilterMode,
  _swigc__p_FloatVector,
  _swigc__p_FrameDescription,
  _swigc__p_FrameStatistics,
  _swigc__p_GLPipe__BlendState,
  _swigc__p_GLPipe__DepthState,
  _swigc__p_GLPipe__FBO,
  _swigc__p_GLPipe__Feedback,
  _swigc__p_GLPipe__FixedVertexProcessing,
  _swigc__p_GLPipe__FrameBuffer,
  _swigc__p_GLPipe__Hints,
  _swigc__p_GLPipe__Rasterizer,
  _swigc__p_GLPipe__RasterizerState,
  _swigc__p_GLPipe__Shader,
  _swigc__p_GLPipe__State,
  _swigc__p_GLPipe__StencilState,
  _swigc__p_GLPipe__TextureCompleteness,
  _swigc__p_GLPipe__VertexAttribute,
  _swigc__p_GLPipe__VertexBuffer,
  _swigc__p_GLPipe__VertexInput,
  _swigc__p_GPUCounter,
  _swigc__p_GPUDevice,
  _swigc__p_GPUVendor,
  _swigc__p_GlobalEnvironment,
  _swigc__p_GraphicsAPI,
  _swigc__p_HWND__,
  _swigc__p_ICamera,
  _swigc__p_ICaptureAccess,
  _swigc__p_ICaptureFile,
  _swigc__p_IDeviceProtocolController,
  _swigc__p_IRemoteServer,
  _swigc__p_IReplayController,
  _swigc__p_IReplayOutput,
  _swigc__p_ITargetControl,
  _swigc__p_IndexBindStats,
  _swigc__p_InstructionSourceInfo,
  _swigc__p_KnownShaderTool,
  _swigc__p_LayoutBindStats,
  _swigc__p_LineColumnInfo,
  _swigc__p_LineRaster,
  _swigc__p_LogType,
  _swigc__p_LogicOperation,
  _swigc__p_MeshDataStage,
  _swigc__p_MeshDisplay,
  _swigc__p_MeshFormat,
  _swigc__p_MeshletSize,
  _swigc__p_MessageCategory,
  _swigc__p_MessageSeverity,
  _swigc__p_MessageSource,
  _swigc__p_ModificationValue,
  _swigc__p_NewCaptureData,
  _swigc__p_NewChildData,
  _swigc__p_Offset,
  _swigc__p_OutputTargetStats,
  _swigc__p_PathEntry,
  _swigc__p_PathProperty,
  _swigc__p_PipeState,
  _swigc__p_PixelModification,
  _swigc__p_PixelValue,
  _swigc__p_PointerVal,
  _swigc__p_QualityHint,
  _swigc__p_RasterState,
  _swigc__p_RasterizationStats,
  _swigc__p_ReplayOptimisationLevel,
  _swigc__p_ReplayOptions,
  _swigc__p_ReplayOutputType,
  _swigc__p_ReplaySupport,
  _swigc__p_ResourceBindStats,
  _swigc__p_ResourceDescription,
  _swigc__p_ResourceFormat,
  _swigc__p_ResourceFormatType,
  _swigc__p_ResourceId,
  _swigc__p_ResourceType,
  _swigc__p_ResourceUpdateStats,
  _swigc__p_ResourceUsage,
  _swigc__p_ResultCode,
  _swigc__p_ResultDetails,
  _swigc__p_SDBasic,
  _swigc__p_SDChunk,
  _swigc__p_SDChunkFlags,
  _swigc__p_SDChunkMetaData,
  _swigc__p_SDFile,
  _swigc__p_SDObject,
  _swigc__p_SDObjectData,
  _swigc__p_SDObjectPODData,
  _swigc__p_SDType,
  _swigc__p_SDTypeFlags,
  _swigc__p_SamplerBindStats,
  _swigc__p_SamplerDescriptor,
  _swigc__p_Scissor,
  _swigc__p_SectionFlags,
  _swigc__p_SectionProperties,
  _swigc__p_SectionType,
  _swigc__p_ShaderBindIndex,
  _swigc__p_ShaderBuiltin,
  _swigc__p_ShaderChangeStats,
  _swigc__p_ShaderCompileFlag,
  _swigc__p_ShaderCompileFlags,
  _swigc__p_ShaderComputeMessageLocation,
  _swigc__p_ShaderConstant,
  _swigc__p_ShaderConstantType,
  _swigc__p_ShaderDebugInfo,
  _swigc__p_ShaderDebugState,
  _swigc__p_ShaderDebugTrace,
  _swigc__p_ShaderDebugger,
  _swigc__p_ShaderDirectAccess,
  _swigc__p_ShaderEncoding,
  _swigc__p_ShaderEntryPoint,
  _swigc__p_ShaderEvents,
  _swigc__p_ShaderGeometryMessageLocation,
  _swigc__p_ShaderMeshMessageLocation,
  _swigc__p_ShaderMessage,
  _swigc__p_ShaderMessageLocation,
  _swigc__p_ShaderPixelMessageLocation,
  _swigc__p_ShaderReflection,
  _swigc__p_ShaderResource,
  _swigc__p_ShaderSampler,
  _swigc__p_ShaderSourceFile,
  _swigc__p_ShaderSourcePrefix,
  _swigc__p_ShaderStage,
  _swigc__p_ShaderStageMask,
  _swigc__p_ShaderValue,
  _swigc__p_ShaderVariable,
  _swigc__p_ShaderVariableChange,
  _swigc__p_ShaderVariableFlags,
  _swigc__p_ShaderVertexMessageLocation,
  _swigc__p_ShadingRateCombiner,
  _swigc__p_SigParameter,
  _swigc__p_SourceVariableMapping,
  _swigc__p_StencilFace,
  _swigc__p_StencilOperation,
  _swigc__p_StructuredBufferList,
  _swigc__p_StructuredChunkList,
  _swigc__p_StructuredObjectList,
  _swigc__p_Subresource,
  _swigc__p_SwigPyObject,
  _swigc__p_TargetControlMessage,
  _swigc__p_TargetControlMessageType,
  _swigc__p_TaskGroupSize,
  _swigc__p_TextureCategory,
  _swigc__p_TextureComponentMapping,
  _swigc__p_TextureDescription,
  _swigc__p_TextureDisplay,
  _swigc__p_TextureFilter,
  _swigc__p_TextureSampleMapping,
  _swigc__p_TextureSave,
  _swigc__p_TextureSliceMapping,
  _swigc__p_TextureSwizzle,
  _swigc__p_TextureSwizzle4,
  _swigc__p_TextureType,
  _swigc__p_Thumbnail,
  _swigc__p_Topology,
  _swigc__p_UsedDescriptor,
  _swigc__p_Uuid,
  _swigc__p_VKPipe__ColorBlendState,
  _swigc__p_VKPipe__ConditionalRendering,
  _swigc__p_VKPipe__CurrentPass,
  _swigc__p_VKPipe__DepthStencil,
  _swigc__p_VKPipe__DescriptorBuffer,
  _swigc__p_VKPipe__DescriptorSet,
  _swigc__p_VKPipe__DynamicOffset,
  _swigc__p_VKPipe__Framebuffer,
  _swigc__p_VKPipe__ImageData,
  _swigc__p_VKPipe__ImageLayout,
  _swigc__p_VKPipe__IndexBuffer,
  _swigc__p_VKPipe__InputAssembly,
  _swigc__p_VKPipe__MultiSample,
  _swigc__p_VKPipe__Pipeline,
  _swigc__p_VKPipe__Rasterizer,
  _swigc__p_VKPipe__RenderArea,
  _swigc__p_VKPipe__RenderPass,
  _swigc__p_VKPipe__SampleLocations,
  _swigc__p_VKPipe__Shader,
  _swigc__p_VKPipe__State,
  _swigc__p_VKPipe__Tessellation,
  _swigc__p_VKPipe__TransformFeedback,
  _swigc__p_VKPipe__VertexAttribute,
  _swigc__p_VKPipe__VertexBinding,
  _swigc__p_VKPipe__VertexBuffer,
  _swigc__p_VKPipe__VertexInput,
  _swigc__p_VKPipe__ViewState,
  _swigc__p_VKPipe__ViewportScissor,
  _swigc__p_VKPipe__XFBBuffer,
  _swigc__p_VarType,
  _swigc__p_VertexBindStats,
  _swigc__p_VertexInputAttribute,
  _swigc__p_Viewport,
  _swigc__p_Visualisation,
  _swigc__p_VulkanLayerFlags,
  _swigc__p_VulkanLayerRegistrationInfo,
  _swigc__p_WindowingData,
  _swigc__p_WindowingSystem,
  _swigc__p_YcbcrConversion,
  _swigc__p_YcbcrRange,
  _swigc__p__XDisplay,
  _swigc__p_bytebuf,
  _swigc__p_char,
  _swigc__p_int,
  _swigc__p_long,
  _swigc__p_p_IRemoteServer,
  _swigc__p_rdcarrayT_APIEvent_t,
  _swigc__p_rdcarrayT_ActionDescription_t,
  _swigc__p_rdcarrayT_BoundVBuffer_t,
  _swigc__p_rdcarrayT_BufferDescription_t,
  _swigc__p_rdcarrayT_CaptureFileFormat_t,
  _swigc__p_rdcarrayT_ColorBlend_t,
  _swigc__p_rdcarrayT_ConstantBindStats_t,
  _swigc__p_rdcarrayT_ConstantBlock_t,
  _swigc__p_rdcarrayT_CounterResult_t,
  _swigc__p_rdcarrayT_D3D11Pipe__Layout_t,
  _swigc__p_rdcarrayT_D3D11Pipe__StreamOutBind_t,
  _swigc__p_rdcarrayT_D3D11Pipe__VertexBuffer_t,
  _swigc__p_rdcarrayT_D3D12Pipe__Layout_t,
  _swigc__p_rdcarrayT_D3D12Pipe__ResourceData_t,
  _swigc__p_rdcarrayT_D3D12Pipe__ResourceState_t,
  _swigc__p_rdcarrayT_D3D12Pipe__RootParam_t,
  _swigc__p_rdcarrayT_D3D12Pipe__RootTableRange_t,
  _swigc__p_rdcarrayT_D3D12Pipe__StaticSampler_t,
  _swigc__p_rdcarrayT_D3D12Pipe__StreamOutBind_t,
  _swigc__p_rdcarrayT_D3D12Pipe__VertexBuffer_t,
  _swigc__p_rdcarrayT_DebugMessage_t,
  _swigc__p_rdcarrayT_DebugVariableReference_t,
  _swigc__p_rdcarrayT_DescriptorAccess_t,
  _swigc__p_rdcarrayT_DescriptorLogicalLocation_t,
  _swigc__p_rdcarrayT_DescriptorRange_t,
  _swigc__p_rdcarrayT_DescriptorStoreDescription_t,
  _swigc__p_rdcarrayT_Descriptor_t,
  _swigc__p_rdcarrayT_EnvironmentModification_t,
  _swigc__p_rdcarrayT_EventUsage_t,
  _swigc__p_rdcarrayT_FloatVector_t,
  _swigc__p_rdcarrayT_GLPipe__TextureCompleteness_t,
  _swigc__p_rdcarrayT_GLPipe__VertexAttribute_t,
  _swigc__p_rdcarrayT_GLPipe__VertexBuffer_t,
  _swigc__p_rdcarrayT_GPUCounter_t,
  _swigc__p_rdcarrayT_GPUDevice_t,
  _swigc__p_rdcarrayT_GraphicsAPI_t,
  _swigc__p_rdcarrayT_InstructionSourceInfo_t,
  _swigc__p_rdcarrayT_LineColumnInfo_t,
  _swigc__p_rdcarrayT_MeshletSize_t,
  _swigc__p_rdcarrayT_Offset_t,
  _swigc__p_rdcarrayT_PathEntry_t,
  _swigc__p_rdcarrayT_PixelModification_t,
  _swigc__p_rdcarrayT_ResourceBindStats_t,
  _swigc__p_rdcarrayT_ResourceDescription_t,
  _swigc__p_rdcarrayT_ResourceId_t,
  _swigc__p_rdcarrayT_SamplerBindStats_t,
  _swigc__p_rdcarrayT_SamplerDescriptor_t,
  _swigc__p_rdcarrayT_Scissor_t,
  _swigc__p_rdcarrayT_ShaderChangeStats_t,
  _swigc__p_rdcarrayT_ShaderCompileFlag_t,
  _swigc__p_rdcarrayT_ShaderConstantType_t,
  _swigc__p_rdcarrayT_ShaderConstant_t,
  _swigc__p_rdcarrayT_ShaderDebugState_t,
  _swigc__p_rdcarrayT_ShaderEncoding_t,
  _swigc__p_rdcarrayT_ShaderEntryPoint_t,
  _swigc__p_rdcarrayT_ShaderMessage_t,
  _swigc__p_rdcarrayT_ShaderResource_t,
  _swigc__p_rdcarrayT_ShaderSampler_t,
  _swigc__p_rdcarrayT_ShaderSourceFile_t,
  _swigc__p_rdcarrayT_ShaderSourcePrefix_t,
  _swigc__p_rdcarrayT_ShaderVariableChange_t,
  _swigc__p_rdcarrayT_ShaderVariable_t,
  _swigc__p_rdcarrayT_SigParameter_t,
  _swigc__p_rdcarrayT_SourceVariableMapping_t,
  _swigc__p_rdcarrayT_TaskGroupSize_t,
  _swigc__p_rdcarrayT_TextureDescription_t,
  _swigc__p_rdcarrayT_UsedDescriptor_t,
  _swigc__p_rdcarrayT_VKPipe__DescriptorBuffer_t,
  _swigc__p_rdcarrayT_VKPipe__DescriptorSet_t,
  _swigc__p_rdcarrayT_VKPipe__DynamicOffset_t,
  _swigc__p_rdcarrayT_VKPipe__ImageData_t,
  _swigc__p_rdcarrayT_VKPipe__ImageLayout_t,
  _swigc__p_rdcarrayT_VKPipe__RenderArea_t,
  _swigc__p_rdcarrayT_VKPipe__VertexAttribute_t,
  _swigc__p_rdcarrayT_VKPipe__VertexBinding_t,
  _swigc__p_rdcarrayT_VKPipe__VertexBuffer_t,
  _swigc__p_rdcarrayT_VKPipe__ViewportScissor_t,
  _swigc__p_rdcarrayT_VKPipe__XFBBuffer_t,
  _swigc__p_rdcarrayT_VertexInputAttribute_t,
  _swigc__p_rdcarrayT_Viewport_t,
  _swigc__p_rdcarrayT_WindowingSystem_t,
  _swigc__p_rdcarrayT_float_t,
  _swigc__p_rdcarrayT_int_t,
  _swigc__p_rdcarrayT_rdcstr_t,
  _swigc__p_rdcarrayT_unsigned_int_t,
  _swigc__p_rdcarrayT_unsigned_long_t,
  _swigc__p_rdcfixedarrayT_ResourceId_4_t,
  _swigc__p_rdcfixedarrayT_ResourceId_8_t,
  _swigc__p_rdcfixedarrayT_bool_4_t,
  _swigc__p_rdcfixedarrayT_bool_8_t,
  _swigc__p_rdcfixedarrayT_double_16_t,
  _swigc__p_rdcfixedarrayT_float_16_t,
  _swigc__p_rdcfixedarrayT_float_2_t,
  _swigc__p_rdcfixedarrayT_float_4_t,
  _swigc__p_rdcfixedarrayT_int_16_t,
  _swigc__p_rdcfixedarrayT_int_4_t,
  _swigc__p_rdcfixedarrayT_long_16_t,
  _swigc__p_rdcfixedarrayT_rdhalf_16_t,
  _swigc__p_rdcfixedarrayT_short_16_t,
  _swigc__p_rdcfixedarrayT_signed_char_16_t,
  _swigc__p_rdcfixedarrayT_unsigned_char_16_t,
  _swigc__p_rdcfixedarrayT_unsigned_int_16_t,
  _swigc__p_rdcfixedarrayT_unsigned_int_3_t,
  _swigc__p_rdcfixedarrayT_unsigned_int_4_t,
  _swigc__p_rdcfixedarrayT_unsigned_long_16_t,
  _swigc__p_rdcfixedarrayT_unsigned_long_4_t,
  _swigc__p_rdcfixedarrayT_unsigned_short_16_t,
  _swigc__p_rdcinflexiblestr,
  _swigc__p_rdcpairT_ShadingRateCombiner_ShadingRateCombiner_t,
  _swigc__p_rdcpairT_unsigned_int_unsigned_int_t,
  _swigc__p_rdcstr,
  _swigc__p_short,
  _swigc__p_signed_char,
  _swigc__p_std__functionT_WindowingData_fbool_rdcarrayT_WindowingSystem_t_const_RF_t,
  _swigc__p_std__functionT_bool_fAPIEvent_const_RF_t,
  _swigc__p_std__functionT_bool_fActionDescription_const_RF_t,
  _swigc__p_std__functionT_bool_fBoundVBuffer_const_RF_t,
  _swigc__p_std__functionT_bool_fBufferDescription_const_RF_t,
  _swigc__p_std__functionT_bool_fCaptureFileFormat_const_RF_t,
  _swigc__p_std__functionT_bool_fColorBlend_const_RF_t,
  _swigc__p_std__functionT_bool_fConstantBindStats_const_RF_t,
  _swigc__p_std__functionT_bool_fConstantBlock_const_RF_t,
  _swigc__p_std__functionT_bool_fCounterResult_const_RF_t,
  _swigc__p_std__functionT_bool_fD3D11Pipe__Layout_const_RF_t,
  _swigc__p_std__functionT_bool_fD3D11Pipe__StreamOutBind_const_RF_t,
  _swigc__p_std__functionT_bool_fD3D11Pipe__VertexBuffer_const_RF_t,
  _swigc__p_std__functionT_bool_fD3D12Pipe__Layout_const_RF_t,
  _swigc__p_std__functionT_bool_fD3D12Pipe__ResourceData_const_RF_t,
  _swigc__p_std__functionT_bool_fD3D12Pipe__ResourceState_const_RF_t,
  _swigc__p_std__functionT_bool_fD3D12Pipe__RootParam_const_RF_t,
  _swigc__p_std__functionT_bool_fD3D12Pipe__RootTableRange_const_RF_t,
  _swigc__p_std__functionT_bool_fD3D12Pipe__StaticSampler_const_RF_t,
  _swigc__p_std__functionT_bool_fD3D12Pipe__StreamOutBind_const_RF_t,
  _swigc__p_std__functionT_bool_fD3D12Pipe__VertexBuffer_const_RF_t,
  _swigc__p_std__functionT_bool_fDebugMessage_const_RF_t,
  _swigc__p_std__functionT_bool_fDebugVariableReference_const_RF_t,
  _swigc__p_std__functionT_bool_fDescriptorAccess_const_RF_t,
  _swigc__p_std__functionT_bool_fDescriptorLogicalLocation_const_RF_t,
  _swigc__p_std__functionT_bool_fDescriptorRange_const_RF_t,
  _swigc__p_std__functionT_bool_fDescriptorStoreDescription_const_RF_t,
  _swigc__p_std__functionT_bool_fDescriptor_const_RF_t,
  _swigc__p_std__functionT_bool_fEnvironmentModification_const_RF_t,
  _swigc__p_std__functionT_bool_fEventUsage_const_RF_t,
  _swigc__p_std__functionT_bool_fF_t,
  _swigc__p_std__functionT_bool_fFloatVector_const_RF_t,
  _swigc__p_std__functionT_bool_fGLPipe__TextureCompleteness_const_RF_t,
  _swigc__p_std__functionT_bool_fGLPipe__VertexAttribute_const_RF_t,
  _swigc__p_std__functionT_bool_fGLPipe__VertexBuffer_const_RF_t,
  _swigc__p_std__functionT_bool_fGPUCounter_const_RF_t,
  _swigc__p_std__functionT_bool_fGPUDevice_const_RF_t,
  _swigc__p_std__functionT_bool_fGraphicsAPI_const_RF_t,
  _swigc__p_std__functionT_bool_fInstructionSourceInfo_const_RF_t,
  _swigc__p_std__functionT_bool_fLineColumnInfo_const_RF_t,
  _swigc__p_std__functionT_bool_fMeshletSize_const_RF_t,
  _swigc__p_std__functionT_bool_fOffset_const_RF_t,
  _swigc__p_std__functionT_bool_fPathEntry_const_RF_t,
  _swigc__p_std__functionT_bool_fPixelModification_const_RF_t,
  _swigc__p_std__functionT_bool_fResourceBindStats_const_RF_t,
  _swigc__p_std__functionT_bool_fResourceDescription_const_RF_t,
  _swigc__p_std__functionT_bool_fResourceId_const_RF_t,
  _swigc__p_std__functionT_bool_fSamplerBindStats_const_RF_t,
  _swigc__p_std__functionT_bool_fSamplerDescriptor_const_RF_t,
  _swigc__p_std__functionT_bool_fScissor_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderChangeStats_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderCompileFlag_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderConstantType_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderConstant_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderDebugState_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderEncoding_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderEntryPoint_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderMessage_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderResource_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderSampler_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderSourceFile_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderSourcePrefix_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderVariableChange_const_RF_t,
  _swigc__p_std__functionT_bool_fShaderVariable_const_RF_t,
  _swigc__p_std__functionT_bool_fSigParameter_const_RF_t,
  _swigc__p_std__functionT_bool_fSourceVariableMapping_const_RF_t,
  _swigc__p_std__functionT_bool_fTaskGroupSize_const_RF_t,
  _swigc__p_std__functionT_bool_fTextureDescription_const_RF_t,
  _swigc__p_std__functionT_bool_fUsedDescriptor_const_RF_t,
  _swigc__p_std__functionT_bool_fVKPipe__DescriptorBuffer_const_RF_t,
  _swigc__p_std__functionT_bool_fVKPipe__DescriptorSet_const_RF_t,
  _swigc__p_std__functionT_bool_fVKPipe__DynamicOffset_const_RF_t,
  _swigc__p_std__functionT_bool_fVKPipe__ImageData_const_RF_t,
  _swigc__p_std__functionT_bool_fVKPipe__ImageLayout_const_RF_t,
  _swigc__p_std__functionT_bool_fVKPipe__RenderArea_const_RF_t,
  _swigc__p_std__functionT_bool_fVKPipe__VertexAttribute_const_RF_t,
  _swigc__p_std__functionT_bool_fVKPipe__VertexBinding_const_RF_t,
  _swigc__p_std__functionT_bool_fVKPipe__VertexBuffer_const_RF_t,
  _swigc__p_std__functionT_bool_fVKPipe__ViewportScissor_const_RF_t,
  _swigc__p_std__functionT_bool_fVKPipe__XFBBuffer_const_RF_t,
  _swigc__p_std__functionT_bool_fVertexInputAttribute_const_RF_t,
  _swigc__p_std__functionT_bool_fViewport_const_RF_t,
  _swigc__p_std__functionT_bool_fWindowingSystem_const_RF_t,
  _swigc__p_std__functionT_bool_ffloat_const_RF_t,
  _swigc__p_std__functionT_bool_fint_const_RF_t,
  _swigc__p_std__functionT_bool_frdcstr_const_RF_t,
  _swigc__p_std__functionT_bool_funsigned_int_const_RF_t,
  _swigc__p_std__functionT_bool_funsigned_long_const_RF_t,
  _swigc__p_std__functionT_void_ffloatF_t,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long,
  _swigc__p_unsigned_short,
  _swigc__p_value_type,
  _swigc__p_wl_display,
  _swigc__p_wl_surface,
  _swigc__p_xcb_connection_t,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
static PyTypeObject *builtin_bases[3];

/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

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

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
        if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
          cast->type = ret;
          ret = 0;
        } else {
          /* Check for casting already in the list */
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
          if (!ocast) ret = 0;
        }
      }
      
      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

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



#ifdef __cplusplus
extern "C" {
#endif
  
  /* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
  
  /* -----------------------------------------------------------------------------
   * global variable support code.
   * ----------------------------------------------------------------------------- */
  
  typedef struct swig_globalvar {
    char       *name;                  /* Name of global variable */
    PyObject *(*get_attr)(void);       /* Return the current value */
    int       (*set_attr)(PyObject *); /* Set the value */
    struct swig_globalvar *next;
  } swig_globalvar;
  
  typedef struct swig_varlinkobject {
    PyObject_HEAD
    swig_globalvar *vars;
  } swig_varlinkobject;
  
  SWIGINTERN PyObject *
  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
    return PyUnicode_InternFromString("<Swig global variables>");
#else
    return PyString_FromString("<Swig global variables>");
#endif
  }
  
  SWIGINTERN PyObject *
  swig_varlink_str(swig_varlinkobject *v) {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *str = PyUnicode_InternFromString("(");
    PyObject *tail;
    PyObject *joined;
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      tail = PyUnicode_FromString(var->name);
      joined = PyUnicode_Concat(str, tail);
      Py_DecRef(str);
      Py_DecRef(tail);
      str = joined;
      if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        Py_DecRef(str);
        Py_DecRef(tail);
        str = joined;
      }
    }
    tail = PyUnicode_InternFromString(")");
    joined = PyUnicode_Concat(str, tail);
    Py_DecRef(str);
    Py_DecRef(tail);
    str = joined;
#else
    PyObject *str = PyString_FromString("(");
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
    }
    PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
    return str;
  }
  
  SWIGINTERN int
  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
    char *tmp;
    PyObject *str = swig_varlink_str(v);
    fprintf(fp,"Swig global variables ");
    fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(str);
    return 0;
  }
  
  SWIGINTERN void
  swig_varlink_dealloc(swig_varlinkobject *v) {
    swig_globalvar *var = v->vars;
    while (var) {
      swig_globalvar *n = var->next;
      free(var->name);
      free(var);
      var = n;
    }
  }
  
  SWIGINTERN PyObject *
  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
    PyObject *res = NULL;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->get_attr)();
        break;
      }
      var = var->next;
    }
    if (res == NULL && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN int
  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
    int res = 1;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->set_attr)(p);
        break;
      }
      var = var->next;
    }
    if (res == 1 && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN PyTypeObject*
  swig_varlink_type(void) {
    static char varlink__doc__[] = "Swig var link object";
    static PyTypeObject varlink_type;
    static int type_init = 0;
    if (!type_init) {
      const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
        PyVarObject_HEAD_INIT(NULL, 0)
#else
        PyObject_HEAD_INIT(NULL)
        0,                                  /* ob_size */
#endif
        (char *)"swigvarlink",              /* tp_name */
        sizeof(swig_varlinkobject),         /* tp_basicsize */
        0,                                  /* tp_itemsize */
        (destructor) swig_varlink_dealloc,  /* tp_dealloc */
        (printfunc) swig_varlink_print,     /* tp_print */
        (getattrfunc) swig_varlink_getattr, /* tp_getattr */
        (setattrfunc) swig_varlink_setattr, /* tp_setattr */
        0,                                  /* tp_compare */
        (reprfunc) swig_varlink_repr,       /* tp_repr */
        0,                                  /* tp_as_number */
        0,                                  /* tp_as_sequence */
        0,                                  /* tp_as_mapping */
        0,                                  /* tp_hash */
        0,                                  /* tp_call */
        (reprfunc) swig_varlink_str,        /* tp_str */
        0,                                  /* tp_getattro */
        0,                                  /* tp_setattro */
        0,                                  /* tp_as_buffer */
        0,                                  /* tp_flags */
        varlink__doc__,                     /* tp_doc */
        0,                                  /* tp_traverse */
        0,                                  /* tp_clear */
        0,                                  /* tp_richcompare */
        0,                                  /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
        0,                                  /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
        0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
        0,                                  /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
        0,                                  /* tp_allocs */
        0,                                  /* tp_frees */
        0,                                  /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
        0,                                  /* tp_prev */
#endif
        0                                   /* tp_next */
#endif
      };
      varlink_type = tmp;
      type_init = 1;
#if PY_VERSION_HEX < 0x02020000
      varlink_type.ob_type = &PyType_Type;
#else
      if (PyType_Ready(&varlink_type) < 0)
      return NULL;
#endif
    }
    return &varlink_type;
  }
  
  /* Create a variable linking object for use later */
  SWIGINTERN PyObject *
  SWIG_Python_newvarlink(void) {
    swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
    if (result) {
      result->vars = 0;
    }
    return ((PyObject*) result);
  }
  
  SWIGINTERN void 
  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
    swig_varlinkobject *v = (swig_varlinkobject *) p;
    swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
    if (gv) {
      size_t size = strlen(name)+1;
      gv->name = (char *)malloc(size);
      if (gv->name) {
        strncpy(gv->name,name,size);
        gv->get_attr = get_attr;
        gv->set_attr = set_attr;
        gv->next = v->vars;
      }
    }
    v->vars = gv;
  }
  
  SWIGINTERN PyObject *
  SWIG_globals(void) {
    static PyObject *_SWIG_globals = 0; 
    if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
    return _SWIG_globals;
  }
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------*/
  /* Fix SwigMethods to carry the callback ptrs when needed */
  /* -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods,
    swig_const_info *const_table,
    swig_type_info **types,
    swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              strncpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              strncpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
  PyObject *m, *d, *md;
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
# if PY_VERSION_HEX >= 0x03020000
    PyModuleDef_HEAD_INIT,
# else
    {
      PyObject_HEAD_INIT(NULL)
      NULL, /* m_init */
      0,    /* m_index */
      NULL, /* m_copy */
    },
# endif
    (char *) SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#endif
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    (PyCFunction) SwigPyObject_own,
    (PyCFunction) SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  PyObject *enum_module;
  PyObject *Enum_class;
  PyObject *Flag_class;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType();
  assert(metatype);
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#if PY_VERSION_HEX >= 0x03000000
  m = PyModule_Create(&SWIG_module);
#else
  m = Py_InitModule((char *) SWIG_name, SwigMethods);
#endif
  
  /* Try to find strong enum module */
  Enum_class = NULL;
  Flag_class = NULL;
#if PY_VERSION_HEX >= 0x03000000
  enum_module = PyImport_ImportModule("enum");
  
  if (enum_module) {
    Enum_class = PyObject_GetAttrString(enum_module, "IntEnum");
    Flag_class = PyObject_GetAttrString(enum_module, "IntFlag");
  }
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = swigpyobject;
  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
    return NULL;
# else
    return;
# endif
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  
  PyDateTime_IMPORT;
  
  
  /* type '::IReplayOutput' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__IReplayOutput_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoResult",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(IReplayOutput::NoResult)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ReplayOutput'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ReplayOutput", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ReplayOutput");
  d = md;
  
  /* type '::IReplayController' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__IReplayController_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoPreference",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(IReplayController::NoPreference)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ReplayController'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ReplayController", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ReplayController");
  d = md;
  
  /* type '::ITargetControl' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ITargetControl_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'TargetControl'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "TargetControl", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TargetControl");
  d = md;
  
  /* type '::ICaptureAccess' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ICaptureAccess_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'CaptureAccess'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "CaptureAccess", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "CaptureAccess");
  d = md;
  
  /* type '::IRemoteServer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__IRemoteServer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoPreference",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(IRemoteServer::NoPreference)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_basetype = SWIG_MangledTypeQuery("_p_ICaptureAccess");
  if (builtin_basetype && builtin_basetype->clientdata && ((SwigPyClientData *) builtin_basetype->clientdata)->pytype) {
    builtin_bases[builtin_base_count++] = ((SwigPyClientData *) builtin_basetype->clientdata)->pytype;
  } else {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'RemoteServer' as base 'ICaptureAccess' has not been initialized.\n");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'RemoteServer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "RemoteServer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "RemoteServer");
  d = md;
  
  /* type '::ICaptureFile' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ICaptureFile_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_basetype = SWIG_MangledTypeQuery("_p_ICaptureAccess");
  if (builtin_basetype && builtin_basetype->clientdata && ((SwigPyClientData *) builtin_basetype->clientdata)->pytype) {
    builtin_bases[builtin_base_count++] = ((SwigPyClientData *) builtin_basetype->clientdata)->pytype;
  } else {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'CaptureFile' as base 'ICaptureAccess' has not been initialized.\n");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'CaptureFile'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "CaptureFile", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "CaptureFile");
  d = md;
  
  /* type '::ICamera' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ICamera_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'Camera'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "Camera", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "Camera");
  d = md;
  
  /* type '::VulkanLayerRegistrationInfo' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VulkanLayerRegistrationInfo_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VulkanLayerRegistrationInfo'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VulkanLayerRegistrationInfo", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VulkanLayerRegistrationInfo");
  d = md;
  
  /* type '::IDeviceProtocolController' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__IDeviceProtocolController_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'DeviceProtocolController'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "DeviceProtocolController", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DeviceProtocolController");
  d = md;
  
  /* type '::ResourceId' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ResourceId_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ResourceId'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ResourceId", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ResourceId");
  d = md;
  
  /* type '::SDBasic' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SDBasic_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Chunk",SWIG_From_int(static_cast< int >(SDBasic::Chunk)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Struct",SWIG_From_int(static_cast< int >(SDBasic::Struct)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Array",SWIG_From_int(static_cast< int >(SDBasic::Array)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Null",SWIG_From_int(static_cast< int >(SDBasic::Null)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Buffer",SWIG_From_int(static_cast< int >(SDBasic::Buffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "String",SWIG_From_int(static_cast< int >(SDBasic::String)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Enum",SWIG_From_int(static_cast< int >(SDBasic::Enum)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "UnsignedInteger",SWIG_From_int(static_cast< int >(SDBasic::UnsignedInteger)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SignedInteger",SWIG_From_int(static_cast< int >(SDBasic::SignedInteger)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Float",SWIG_From_int(static_cast< int >(SDBasic::Float)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Boolean",SWIG_From_int(static_cast< int >(SDBasic::Boolean)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Character",SWIG_From_int(static_cast< int >(SDBasic::Character)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Resource",SWIG_From_int(static_cast< int >(SDBasic::Resource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPUAddress",SWIG_From_int(static_cast< int >(SDBasic::GPUAddress)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "SDBasic", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "SDBasic", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'SDBasic'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "SDBasic", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SDBasic");
  d = md;
  
  /* type '::SDTypeFlags' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SDTypeFlags_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoFlags",SWIG_From_int(static_cast< int >(SDTypeFlags::NoFlags)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "HasCustomString",SWIG_From_int(static_cast< int >(SDTypeFlags::HasCustomString)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Hidden",SWIG_From_int(static_cast< int >(SDTypeFlags::Hidden)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Nullable",SWIG_From_int(static_cast< int >(SDTypeFlags::Nullable)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NullString",SWIG_From_int(static_cast< int >(SDTypeFlags::NullString)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FixedArray",SWIG_From_int(static_cast< int >(SDTypeFlags::FixedArray)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Union",SWIG_From_int(static_cast< int >(SDTypeFlags::Union)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Important",SWIG_From_int(static_cast< int >(SDTypeFlags::Important)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ImportantChildren",SWIG_From_int(static_cast< int >(SDTypeFlags::ImportantChildren)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "HiddenChildren",SWIG_From_int(static_cast< int >(SDTypeFlags::HiddenChildren)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "OffsetOrSize",SWIG_From_int(static_cast< int >(SDTypeFlags::OffsetOrSize)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    if(Flag_class) constructor = Flag_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "SDTypeFlags", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "SDTypeFlags", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'SDTypeFlags'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "SDTypeFlags", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SDTypeFlags");
  d = md;
  
  /* type '::SDChunkFlags' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SDChunkFlags_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoFlags",SWIG_From_int(static_cast< int >(SDChunkFlags::NoFlags)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "OpaqueChunk",SWIG_From_int(static_cast< int >(SDChunkFlags::OpaqueChunk)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "HasCallstack",SWIG_From_int(static_cast< int >(SDChunkFlags::HasCallstack)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    if(Flag_class) constructor = Flag_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "SDChunkFlags", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "SDChunkFlags", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'SDChunkFlags'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "SDChunkFlags", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SDChunkFlags");
  d = md;
  
  /* type '::SDType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SDType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'SDType'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "SDType", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SDType");
  d = md;
  
  /* type '::SDChunkMetaData' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SDChunkMetaData_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'SDChunkMetaData'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "SDChunkMetaData", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SDChunkMetaData");
  d = md;
  
  /* type '::SDObjectPODData' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SDObjectPODData_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'SDObjectPODData'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "SDObjectPODData", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SDObjectPODData");
  d = md;
  
  /* type '::StructuredObjectList' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__StructuredObjectList_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'StructuredObjectList'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "StructuredObjectList", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "StructuredObjectList");
  d = md;
  
  /* type '::SDObjectData' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SDObjectData_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'SDObjectData'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "SDObjectData", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SDObjectData");
  d = md;
  
  /* type '::SDObject' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SDObject_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'SDObject'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "SDObject", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SDObject");
  d = md;
  
  /* type '::SDChunk' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SDChunk_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_basetype = SWIG_MangledTypeQuery("_p_SDObject");
  if (builtin_basetype && builtin_basetype->clientdata && ((SwigPyClientData *) builtin_basetype->clientdata)->pytype) {
    builtin_bases[builtin_base_count++] = ((SwigPyClientData *) builtin_basetype->clientdata)->pytype;
  } else {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'SDChunk' as base 'SDObject' has not been initialized.\n");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'SDChunk'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "SDChunk", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SDChunk");
  d = md;
  
  /* type '::StructuredChunkList' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__StructuredChunkList_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'StructuredChunkList'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "StructuredChunkList", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "StructuredChunkList");
  d = md;
  
  /* type '::StructuredBufferList' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__StructuredBufferList_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'StructuredBufferList'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "StructuredBufferList", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "StructuredBufferList");
  d = md;
  
  /* type '::SDFile' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SDFile_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'SDFile'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "SDFile", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SDFile");
  d = md;
  
  /* type '::CaptureOptions' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CaptureOptions_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'CaptureOptions'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "CaptureOptions", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "CaptureOptions");
  d = md;
  
  /* type '::TaskGroupSize' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TaskGroupSize_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'TaskGroupSize'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "TaskGroupSize", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TaskGroupSize");
  d = md;
  
  /* type '::MeshletSize' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__MeshletSize_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'MeshletSize'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "MeshletSize", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "MeshletSize");
  d = md;
  
  /* type '::MeshFormat' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__MeshFormat_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'MeshFormat'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "MeshFormat", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "MeshFormat");
  d = md;
  
  /* type '::MeshDisplay' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__MeshDisplay_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoHighlight",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(MeshDisplay::NoHighlight)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'MeshDisplay'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "MeshDisplay", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "MeshDisplay");
  d = md;
  
  /* type '::TextureDisplay' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TextureDisplay_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ResolveSamples",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(TextureDisplay::ResolveSamples)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'TextureDisplay'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "TextureDisplay", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TextureDisplay");
  d = md;
  
  /* type '::TextureComponentMapping' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TextureComponentMapping_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'TextureComponentMapping'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "TextureComponentMapping", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TextureComponentMapping");
  d = md;
  
  /* type '::TextureSampleMapping' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TextureSampleMapping_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ResolveSamples",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(TextureSampleMapping::ResolveSamples)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'TextureSampleMapping'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "TextureSampleMapping", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TextureSampleMapping");
  d = md;
  
  /* type '::TextureSliceMapping' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TextureSliceMapping_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'TextureSliceMapping'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "TextureSliceMapping", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TextureSliceMapping");
  d = md;
  
  /* type '::TextureSave' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TextureSave_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'TextureSave'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "TextureSave", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TextureSave");
  d = md;
  
  /* type '::DescriptorRange' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DescriptorRange_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'DescriptorRange'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "DescriptorRange", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DescriptorRange");
  d = md;
  
  /* type '::NewCaptureData' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__NewCaptureData_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'NewCaptureData'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "NewCaptureData", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "NewCaptureData");
  d = md;
  
  /* type '::APIUseData' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__APIUseData_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'APIUseData'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "APIUseData", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "APIUseData");
  d = md;
  
  /* type '::BusyData' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__BusyData_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'BusyData'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "BusyData", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "BusyData");
  d = md;
  
  /* type '::NewChildData' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__NewChildData_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'NewChildData'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "NewChildData", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "NewChildData");
  d = md;
  
  /* type '::TargetControlMessage' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TargetControlMessage_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'TargetControlMessage'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "TargetControlMessage", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TargetControlMessage");
  d = md;
  
  /* type '::EnvironmentModification' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__EnvironmentModification_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'EnvironmentModification'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "EnvironmentModification", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "EnvironmentModification");
  d = md;
  
  /* type '::CaptureFileFormat' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CaptureFileFormat_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'CaptureFileFormat'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "CaptureFileFormat", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "CaptureFileFormat");
  d = md;
  
  /* type '::GPUDevice' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GPUDevice_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GPUDevice'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GPUDevice", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GPUDevice");
  d = md;
  
  /* type '::ReplayOptions' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ReplayOptions_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ReplayOptions'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ReplayOptions", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ReplayOptions");
  d = md;
  
  /* type '::WindowingData' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__WindowingData_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'WindowingData'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "WindowingData", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "WindowingData");
  d = md;
  
  /* type '::GlobalEnvironment' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GlobalEnvironment_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GlobalEnvironment'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GlobalEnvironment", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GlobalEnvironment");
  d = md;
  
  /* type '::ResultDetails' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ResultDetails_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ResultDetails'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ResultDetails", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ResultDetails");
  d = md;
  
  /* type '::ExecuteResult' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ExecuteResult_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ExecuteResult'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ExecuteResult", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ExecuteResult");
  d = md;
  
  /* type '::Viewport' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__Viewport_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'Viewport'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "Viewport", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "Viewport");
  d = md;
  
  /* type '::Scissor' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__Scissor_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'Scissor'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "Scissor", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "Scissor");
  d = md;
  
  /* type '::BlendEquation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__BlendEquation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'BlendEquation'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "BlendEquation", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "BlendEquation");
  d = md;
  
  /* type '::ColorBlend' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ColorBlend_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ColorBlend'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ColorBlend", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ColorBlend");
  d = md;
  
  /* type '::RasterState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__RasterState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'RasterState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "RasterState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "RasterState");
  d = md;
  
  /* type '::DepthTestState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DepthTestState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'DepthTestState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "DepthTestState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DepthTestState");
  d = md;
  
  /* type '::StencilFace' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__StencilFace_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'StencilFace'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "StencilFace", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "StencilFace");
  d = md;
  
  /* type '::BoundVBuffer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__BoundVBuffer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'BoundVBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "BoundVBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "BoundVBuffer");
  d = md;
  
  /* type '::Descriptor' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__Descriptor_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'Descriptor'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "Descriptor", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "Descriptor");
  d = md;
  
  /* type '::SamplerDescriptor' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SamplerDescriptor_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'SamplerDescriptor'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "SamplerDescriptor", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SamplerDescriptor");
  d = md;
  
  /* type '::DescriptorAccess' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DescriptorAccess_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoShaderBinding",SWIG_From_unsigned_SS_short(static_cast< unsigned short >(DescriptorAccess::NoShaderBinding)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'DescriptorAccess'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "DescriptorAccess", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DescriptorAccess");
  d = md;
  
  /* type '::DescriptorLogicalLocation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DescriptorLogicalLocation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'DescriptorLogicalLocation'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "DescriptorLogicalLocation", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DescriptorLogicalLocation");
  d = md;
  
  /* type '::UsedDescriptor' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__UsedDescriptor_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'UsedDescriptor'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "UsedDescriptor", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "UsedDescriptor");
  d = md;
  
  /* type '::Offset' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__Offset_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'Offset'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "Offset", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "Offset");
  d = md;
  
  /* type '::VertexInputAttribute' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VertexInputAttribute_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VertexInputAttribute'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VertexInputAttribute", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VertexInputAttribute");
  d = md;
  
  /* type '::ShaderMeshMessageLocation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderMeshMessageLocation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NotUsed",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(ShaderMeshMessageLocation::NotUsed)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderMeshMessageLocation'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderMeshMessageLocation", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderMeshMessageLocation");
  d = md;
  
  /* type '::ShaderComputeMessageLocation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderComputeMessageLocation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderComputeMessageLocation'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderComputeMessageLocation", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderComputeMessageLocation");
  d = md;
  
  /* type '::ShaderVertexMessageLocation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderVertexMessageLocation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderVertexMessageLocation'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderVertexMessageLocation", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderVertexMessageLocation");
  d = md;
  
  /* type '::ShaderPixelMessageLocation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderPixelMessageLocation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoLocation",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(ShaderPixelMessageLocation::NoLocation)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderPixelMessageLocation'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderPixelMessageLocation", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderPixelMessageLocation");
  d = md;
  
  /* type '::ShaderGeometryMessageLocation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderGeometryMessageLocation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderGeometryMessageLocation'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderGeometryMessageLocation", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderGeometryMessageLocation");
  d = md;
  
  /* type '::ShaderMessageLocation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderMessageLocation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderMessageLocation'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderMessageLocation", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderMessageLocation");
  d = md;
  
  /* type '::ShaderMessage' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderMessage_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderMessage'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderMessage", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderMessage");
  d = md;
  
  /* type 'D3D11Pipe::Layout' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__Layout_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TightlyPacked",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(D3D11Pipe::Layout::TightlyPacked)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11Layout'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11Layout", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11Layout");
  d = md;
  
  /* type 'D3D11Pipe::VertexBuffer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__VertexBuffer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11VertexBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11VertexBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11VertexBuffer");
  d = md;
  
  /* type 'D3D11Pipe::IndexBuffer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__IndexBuffer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11IndexBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11IndexBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11IndexBuffer");
  d = md;
  
  /* type 'D3D11Pipe::InputAssembly' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__InputAssembly_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11InputAssembly'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11InputAssembly", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11InputAssembly");
  d = md;
  
  /* type 'D3D11Pipe::Shader' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__Shader_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11Shader'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11Shader", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11Shader");
  d = md;
  
  /* type 'D3D11Pipe::StreamOutBind' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__StreamOutBind_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11StreamOutBind'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11StreamOutBind", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11StreamOutBind");
  d = md;
  
  /* type 'D3D11Pipe::StreamOut' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__StreamOut_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoRasterization",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(D3D11Pipe::StreamOut::NoRasterization)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11StreamOut'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11StreamOut", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11StreamOut");
  d = md;
  
  /* type 'D3D11Pipe::RasterizerState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__RasterizerState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11RasterizerState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11RasterizerState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11RasterizerState");
  d = md;
  
  /* type 'D3D11Pipe::Rasterizer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__Rasterizer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11Rasterizer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11Rasterizer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11Rasterizer");
  d = md;
  
  /* type 'D3D11Pipe::DepthStencilState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__DepthStencilState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11DepthStencilState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11DepthStencilState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11DepthStencilState");
  d = md;
  
  /* type 'D3D11Pipe::BlendState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__BlendState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11BlendState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11BlendState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11BlendState");
  d = md;
  
  /* type 'D3D11Pipe::OutputMerger' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__OutputMerger_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11OutputMerger'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11OutputMerger", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11OutputMerger");
  d = md;
  
  /* type 'D3D11Pipe::Predication' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__Predication_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11Predication'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11Predication", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11Predication");
  d = md;
  
  /* type 'D3D11Pipe::State' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D11Pipe__State_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D11State'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D11State", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D11State");
  d = md;
  
  /* type 'D3D12Pipe::Layout' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__Layout_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TightlyPacked",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(D3D12Pipe::Layout::TightlyPacked)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12Layout'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12Layout", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12Layout");
  d = md;
  
  /* type 'D3D12Pipe::VertexBuffer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__VertexBuffer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12VertexBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12VertexBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12VertexBuffer");
  d = md;
  
  /* type 'D3D12Pipe::IndexBuffer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__IndexBuffer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12IndexBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12IndexBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12IndexBuffer");
  d = md;
  
  /* type 'D3D12Pipe::InputAssembly' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__InputAssembly_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12InputAssembly'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12InputAssembly", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12InputAssembly");
  d = md;
  
  /* type 'D3D12Pipe::Shader' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__Shader_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12Shader'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12Shader", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12Shader");
  d = md;
  
  /* type 'D3D12Pipe::StreamOutBind' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__StreamOutBind_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12StreamOutBind'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12StreamOutBind", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12StreamOutBind");
  d = md;
  
  /* type 'D3D12Pipe::StreamOut' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__StreamOut_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoRasterization",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(D3D12Pipe::StreamOut::NoRasterization)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12StreamOut'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12StreamOut", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12StreamOut");
  d = md;
  
  /* type 'D3D12Pipe::RasterizerState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__RasterizerState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12RasterizerState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12RasterizerState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12RasterizerState");
  d = md;
  
  /* type 'D3D12Pipe::Rasterizer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__Rasterizer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12Rasterizer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12Rasterizer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12Rasterizer");
  d = md;
  
  /* type 'D3D12Pipe::DepthStencilState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__DepthStencilState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12DepthStencilState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12DepthStencilState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12DepthStencilState");
  d = md;
  
  /* type 'D3D12Pipe::BlendState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__BlendState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12BlendState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12BlendState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12BlendState");
  d = md;
  
  /* type 'D3D12Pipe::OM' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__OM_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12OM'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12OM", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12OM");
  d = md;
  
  /* type 'D3D12Pipe::ResourceState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__ResourceState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12ResourceState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12ResourceState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12ResourceState");
  d = md;
  
  /* type 'D3D12Pipe::ResourceData' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__ResourceData_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12ResourceData'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12ResourceData", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12ResourceData");
  d = md;
  
  /* type 'D3D12Pipe::RootTableRange' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__RootTableRange_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12RootTableRange'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12RootTableRange", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12RootTableRange");
  d = md;
  
  /* type 'D3D12Pipe::RootParam' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__RootParam_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12RootParam'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12RootParam", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12RootParam");
  d = md;
  
  /* type 'D3D12Pipe::StaticSampler' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__StaticSampler_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12StaticSampler'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12StaticSampler", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12StaticSampler");
  d = md;
  
  /* type 'D3D12Pipe::RootSignature' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__RootSignature_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12RootSignature'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12RootSignature", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12RootSignature");
  d = md;
  
  /* type 'D3D12Pipe::Predication' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__Predication_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12Predication'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12Predication", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12Predication");
  d = md;
  
  /* type 'D3D12Pipe::State' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__D3D12Pipe__State_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'D3D12State'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "D3D12State", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "D3D12State");
  d = md;
  
  /* type '::FloatVector' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__FloatVector_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'FloatVector'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "FloatVector", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "FloatVector");
  d = md;
  
  /* type '::AxisMapping' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__AxisMapping_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'AxisMapping'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "AxisMapping", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "AxisMapping");
  d = md;
  
  /* type '::PathEntry' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__PathEntry_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'PathEntry'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "PathEntry", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "PathEntry");
  d = md;
  
  /* type '::SectionProperties' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SectionProperties_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'SectionProperties'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "SectionProperties", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SectionProperties");
  d = md;
  
  /* type '::ResourceFormat' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ResourceFormat_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ResourceFormat'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ResourceFormat", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ResourceFormat");
  d = md;
  
  /* type '::TextureFilter' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TextureFilter_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'TextureFilter'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "TextureFilter", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TextureFilter");
  d = md;
  
  /* type '::TextureSwizzle4' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TextureSwizzle4_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'TextureSwizzle4'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "TextureSwizzle4", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TextureSwizzle4");
  d = md;
  
  /* type '::ResourceDescription' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ResourceDescription_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ResourceDescription'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ResourceDescription", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ResourceDescription");
  d = md;
  
  /* type '::DescriptorStoreDescription' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DescriptorStoreDescription_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'DescriptorStoreDescription'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "DescriptorStoreDescription", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DescriptorStoreDescription");
  d = md;
  
  /* type '::BufferDescription' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__BufferDescription_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'BufferDescription'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "BufferDescription", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "BufferDescription");
  d = md;
  
  /* type '::TextureDescription' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TextureDescription_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'TextureDescription'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "TextureDescription", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TextureDescription");
  d = md;
  
  /* type '::APIEvent' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__APIEvent_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoChunk",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(APIEvent::NoChunk)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'APIEvent'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "APIEvent", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "APIEvent");
  d = md;
  
  /* type '::DebugMessage' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DebugMessage_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'DebugMessage'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "DebugMessage", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DebugMessage");
  d = md;
  
  /* type '::BucketRecordType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__BucketRecordType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Linear",SWIG_From_int(static_cast< int >(BucketRecordType::Linear)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Pow2",SWIG_From_int(static_cast< int >(BucketRecordType::Pow2)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "BucketRecordType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "BucketRecordType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'BucketRecordType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "BucketRecordType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "BucketRecordType");
  d = md;
  
  /* type '::ConstantBindStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ConstantBindStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BucketType",SWIG_From_int(static_cast< int >(ConstantBindStats::BucketType)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BucketCount",SWIG_From_size_t(static_cast< size_t >(ConstantBindStats::BucketCount)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ConstantBindStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ConstantBindStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ConstantBindStats");
  d = md;
  
  /* type '::SamplerBindStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SamplerBindStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'SamplerBindStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "SamplerBindStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SamplerBindStats");
  d = md;
  
  /* type '::ResourceBindStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ResourceBindStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ResourceBindStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ResourceBindStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ResourceBindStats");
  d = md;
  
  /* type '::ResourceUpdateStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ResourceUpdateStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BucketType",SWIG_From_int(static_cast< int >(ResourceUpdateStats::BucketType)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BucketCount",SWIG_From_size_t(static_cast< size_t >(ResourceUpdateStats::BucketCount)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ResourceUpdateStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ResourceUpdateStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ResourceUpdateStats");
  d = md;
  
  /* type '::DrawcallStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DrawcallStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BucketType",SWIG_From_int(static_cast< int >(DrawcallStats::BucketType)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BucketSize",SWIG_From_size_t(static_cast< size_t >(DrawcallStats::BucketSize)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BucketCount",SWIG_From_size_t(static_cast< size_t >(DrawcallStats::BucketCount)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'DrawcallStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "DrawcallStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DrawcallStats");
  d = md;
  
  /* type '::DispatchStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DispatchStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'DispatchStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "DispatchStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DispatchStats");
  d = md;
  
  /* type '::IndexBindStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__IndexBindStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'IndexBindStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "IndexBindStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "IndexBindStats");
  d = md;
  
  /* type '::VertexBindStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VertexBindStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VertexBindStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VertexBindStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VertexBindStats");
  d = md;
  
  /* type '::LayoutBindStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__LayoutBindStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'LayoutBindStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "LayoutBindStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "LayoutBindStats");
  d = md;
  
  /* type '::ShaderChangeStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderChangeStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderChangeStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderChangeStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderChangeStats");
  d = md;
  
  /* type '::BlendStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__BlendStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'BlendStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "BlendStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "BlendStats");
  d = md;
  
  /* type '::DepthStencilStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DepthStencilStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'DepthStencilStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "DepthStencilStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DepthStencilStats");
  d = md;
  
  /* type '::RasterizationStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__RasterizationStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'RasterizationStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "RasterizationStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "RasterizationStats");
  d = md;
  
  /* type '::OutputTargetStats' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__OutputTargetStats_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'OutputTargetStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "OutputTargetStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "OutputTargetStats");
  d = md;
  
  /* type '::FrameStatistics' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__FrameStatistics_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'FrameStatistics'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "FrameStatistics", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "FrameStatistics");
  d = md;
  
  /* type '::FrameDescription' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__FrameDescription_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoFrameNumber",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FrameDescription::NoFrameNumber)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'FrameDescription'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "FrameDescription", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "FrameDescription");
  d = md;
  
  /* type '::EventUsage' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__EventUsage_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'EventUsage'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "EventUsage", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "EventUsage");
  d = md;
  
  /* type '::Subresource' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__Subresource_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'Subresource'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "Subresource", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "Subresource");
  d = md;
  
  /* type '::ActionDescription' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ActionDescription_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ActionDescription'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ActionDescription", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ActionDescription");
  d = md;
  
  /* type '::APIProperties' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__APIProperties_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'APIProperties'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "APIProperties", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "APIProperties");
  d = md;
  
  /* type '::DriverInformation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DriverInformation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'DriverInformation'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "DriverInformation", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DriverInformation");
  d = md;
  
  /* type '::Uuid' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__Uuid_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'Uuid'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "Uuid", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "Uuid");
  d = md;
  
  /* type '::CounterDescription' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CounterDescription_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'CounterDescription'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "CounterDescription", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "CounterDescription");
  d = md;
  
  /* type '::CounterValue' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CounterValue_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'CounterValue'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "CounterValue", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "CounterValue");
  d = md;
  
  /* type '::CounterResult' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CounterResult_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'CounterResult'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "CounterResult", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "CounterResult");
  d = md;
  
  /* type '::PixelValue' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__PixelValue_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'PixelValue'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "PixelValue", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "PixelValue");
  d = md;
  
  /* type '::ModificationValue' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ModificationValue_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ModificationValue'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ModificationValue", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ModificationValue");
  d = md;
  
  /* type '::PixelModification' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__PixelModification_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'PixelModification'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "PixelModification", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "PixelModification");
  d = md;
  
  /* type '::Thumbnail' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__Thumbnail_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'Thumbnail'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "Thumbnail", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "Thumbnail");
  d = md;
  
  /* type '::DebugPixelInputs' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DebugPixelInputs_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'DebugPixelInputs'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "DebugPixelInputs", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DebugPixelInputs");
  d = md;
  
  /* type 'GLPipe::VertexAttribute' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__VertexAttribute_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLVertexAttribute'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLVertexAttribute", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLVertexAttribute");
  d = md;
  
  /* type 'GLPipe::VertexBuffer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__VertexBuffer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLVertexBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLVertexBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLVertexBuffer");
  d = md;
  
  /* type 'GLPipe::VertexInput' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__VertexInput_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLVertexInput'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLVertexInput", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLVertexInput");
  d = md;
  
  /* type 'GLPipe::Shader' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__Shader_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLShader'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLShader", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLShader");
  d = md;
  
  /* type 'GLPipe::FixedVertexProcessing' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__FixedVertexProcessing_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLFixedVertexProcessing'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLFixedVertexProcessing", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLFixedVertexProcessing");
  d = md;
  
  /* type 'GLPipe::TextureCompleteness' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__TextureCompleteness_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLTextureCompleteness'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLTextureCompleteness", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLTextureCompleteness");
  d = md;
  
  /* type 'GLPipe::Feedback' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__Feedback_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLFeedback'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLFeedback", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLFeedback");
  d = md;
  
  /* type 'GLPipe::RasterizerState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__RasterizerState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLRasterizerState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLRasterizerState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLRasterizerState");
  d = md;
  
  /* type 'GLPipe::Rasterizer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__Rasterizer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLRasterizer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLRasterizer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLRasterizer");
  d = md;
  
  /* type 'GLPipe::DepthState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__DepthState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLDepthState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLDepthState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLDepthState");
  d = md;
  
  /* type 'GLPipe::StencilState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__StencilState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLStencilState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLStencilState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLStencilState");
  d = md;
  
  /* type 'GLPipe::FBO' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__FBO_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLFBO'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLFBO", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLFBO");
  d = md;
  
  /* type 'GLPipe::BlendState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__BlendState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLBlendState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLBlendState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLBlendState");
  d = md;
  
  /* type 'GLPipe::FrameBuffer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__FrameBuffer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLFrameBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLFrameBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLFrameBuffer");
  d = md;
  
  /* type 'GLPipe::Hints' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__Hints_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLHints'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLHints", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLHints");
  d = md;
  
  /* type 'GLPipe::State' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GLPipe__State_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'GLState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "GLState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GLState");
  d = md;
  
  /* type '::SectionType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SectionType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(SectionType::Unknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "First",SWIG_From_int(static_cast< int >(SectionType::First)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FrameCapture",SWIG_From_int(static_cast< int >(SectionType::FrameCapture)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ResolveDatabase",SWIG_From_int(static_cast< int >(SectionType::ResolveDatabase)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Bookmarks",SWIG_From_int(static_cast< int >(SectionType::Bookmarks)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Notes",SWIG_From_int(static_cast< int >(SectionType::Notes)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ResourceRenames",SWIG_From_int(static_cast< int >(SectionType::ResourceRenames)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AMDRGPProfile",SWIG_From_int(static_cast< int >(SectionType::AMDRGPProfile)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ExtendedThumbnail",SWIG_From_int(static_cast< int >(SectionType::ExtendedThumbnail)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "EmbeddedLogfile",SWIG_From_int(static_cast< int >(SectionType::EmbeddedLogfile)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "EditedShaders",SWIG_From_int(static_cast< int >(SectionType::EditedShaders)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "D3D12Core",SWIG_From_int(static_cast< int >(SectionType::D3D12Core)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "D3D12SDKLayers",SWIG_From_int(static_cast< int >(SectionType::D3D12SDKLayers)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "EmbeddedExternalFiles",SWIG_From_int(static_cast< int >(SectionType::EmbeddedExternalFiles)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Count",SWIG_From_int(static_cast< int >(SectionType::Count)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "SectionType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "SectionType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'SectionType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "SectionType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SectionType");
  d = md;
  
  /* type '::DebugVariableType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DebugVariableType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Undefined",SWIG_From_int(static_cast< int >(DebugVariableType::Undefined)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Input",SWIG_From_int(static_cast< int >(DebugVariableType::Input)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Constant",SWIG_From_int(static_cast< int >(DebugVariableType::Constant)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Sampler",SWIG_From_int(static_cast< int >(DebugVariableType::Sampler)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadOnlyResource",SWIG_From_int(static_cast< int >(DebugVariableType::ReadOnlyResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadWriteResource",SWIG_From_int(static_cast< int >(DebugVariableType::ReadWriteResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Variable",SWIG_From_int(static_cast< int >(DebugVariableType::Variable)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "DebugVariableType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "DebugVariableType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'DebugVariableType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "DebugVariableType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DebugVariableType");
  d = md;
  
  /* type '::VarType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VarType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Float",SWIG_From_int(static_cast< int >(VarType::Float)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Double",SWIG_From_int(static_cast< int >(VarType::Double)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Half",SWIG_From_int(static_cast< int >(VarType::Half)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SInt",SWIG_From_int(static_cast< int >(VarType::SInt)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "UInt",SWIG_From_int(static_cast< int >(VarType::UInt)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SShort",SWIG_From_int(static_cast< int >(VarType::SShort)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "UShort",SWIG_From_int(static_cast< int >(VarType::UShort)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SLong",SWIG_From_int(static_cast< int >(VarType::SLong)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ULong",SWIG_From_int(static_cast< int >(VarType::ULong)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SByte",SWIG_From_int(static_cast< int >(VarType::SByte)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "UByte",SWIG_From_int(static_cast< int >(VarType::UByte)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Bool",SWIG_From_int(static_cast< int >(VarType::Bool)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Enum",SWIG_From_int(static_cast< int >(VarType::Enum)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Struct",SWIG_From_int(static_cast< int >(VarType::Struct)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPUPointer",SWIG_From_int(static_cast< int >(VarType::GPUPointer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ConstantBlock",SWIG_From_int(static_cast< int >(VarType::ConstantBlock)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadOnlyResource",SWIG_From_int(static_cast< int >(VarType::ReadOnlyResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadWriteResource",SWIG_From_int(static_cast< int >(VarType::ReadWriteResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Sampler",SWIG_From_int(static_cast< int >(VarType::Sampler)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(VarType::Unknown)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "VarType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "VarType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'VarType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "VarType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VarType");
  d = md;
  
  /* type '::CompType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CompType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Typeless",SWIG_From_int(static_cast< int >(CompType::Typeless)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Float",SWIG_From_int(static_cast< int >(CompType::Float)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "UNorm",SWIG_From_int(static_cast< int >(CompType::UNorm)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SNorm",SWIG_From_int(static_cast< int >(CompType::SNorm)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "UInt",SWIG_From_int(static_cast< int >(CompType::UInt)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SInt",SWIG_From_int(static_cast< int >(CompType::SInt)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "UScaled",SWIG_From_int(static_cast< int >(CompType::UScaled)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SScaled",SWIG_From_int(static_cast< int >(CompType::SScaled)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Depth",SWIG_From_int(static_cast< int >(CompType::Depth)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "UNormSRGB",SWIG_From_int(static_cast< int >(CompType::UNormSRGB)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "CompType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "CompType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'CompType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "CompType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "CompType");
  d = md;
  
  /* type '::TextureSwizzle' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TextureSwizzle_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Red",SWIG_From_int(static_cast< int >(TextureSwizzle::Red)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Green",SWIG_From_int(static_cast< int >(TextureSwizzle::Green)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Blue",SWIG_From_int(static_cast< int >(TextureSwizzle::Blue)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Alpha",SWIG_From_int(static_cast< int >(TextureSwizzle::Alpha)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Zero",SWIG_From_int(static_cast< int >(TextureSwizzle::Zero)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "One",SWIG_From_int(static_cast< int >(TextureSwizzle::One)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "TextureSwizzle", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "TextureSwizzle", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'TextureSwizzle'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "TextureSwizzle", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TextureSwizzle");
  d = md;
  
  /* type '::AddressMode' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__AddressMode_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Wrap",SWIG_From_int(static_cast< int >(AddressMode::Wrap)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Repeat",SWIG_From_int(static_cast< int >(AddressMode::Repeat)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Mirror",SWIG_From_int(static_cast< int >(AddressMode::Mirror)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MirrorRepeat",SWIG_From_int(static_cast< int >(AddressMode::MirrorRepeat)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MirrorOnce",SWIG_From_int(static_cast< int >(AddressMode::MirrorOnce)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MirrorClamp",SWIG_From_int(static_cast< int >(AddressMode::MirrorClamp)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ClampEdge",SWIG_From_int(static_cast< int >(AddressMode::ClampEdge)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ClampBorder",SWIG_From_int(static_cast< int >(AddressMode::ClampBorder)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "AddressMode", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "AddressMode", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'AddressMode'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "AddressMode", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "AddressMode");
  d = md;
  
  /* type '::YcbcrConversion' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__YcbcrConversion_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Raw",SWIG_From_int(static_cast< int >(YcbcrConversion::Raw)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RangeOnly",SWIG_From_int(static_cast< int >(YcbcrConversion::RangeOnly)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BT709",SWIG_From_int(static_cast< int >(YcbcrConversion::BT709)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BT601",SWIG_From_int(static_cast< int >(YcbcrConversion::BT601)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BT2020",SWIG_From_int(static_cast< int >(YcbcrConversion::BT2020)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "YcbcrConversion", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "YcbcrConversion", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'YcbcrConversion'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "YcbcrConversion", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "YcbcrConversion");
  d = md;
  
  /* type '::YcbcrRange' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__YcbcrRange_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ITUFull",SWIG_From_int(static_cast< int >(YcbcrRange::ITUFull)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ITUNarrow",SWIG_From_int(static_cast< int >(YcbcrRange::ITUNarrow)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "YcbcrRange", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "YcbcrRange", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'YcbcrRange'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "YcbcrRange", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "YcbcrRange");
  d = md;
  
  /* type '::ChromaSampleLocation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ChromaSampleLocation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CositedEven",SWIG_From_int(static_cast< int >(ChromaSampleLocation::CositedEven)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Midpoint",SWIG_From_int(static_cast< int >(ChromaSampleLocation::Midpoint)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ChromaSampleLocation", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ChromaSampleLocation", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ChromaSampleLocation'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ChromaSampleLocation", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ChromaSampleLocation");
  d = md;
  
  /* type '::ResourceType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ResourceType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(ResourceType::Unknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Device",SWIG_From_int(static_cast< int >(ResourceType::Device)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Queue",SWIG_From_int(static_cast< int >(ResourceType::Queue)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CommandBuffer",SWIG_From_int(static_cast< int >(ResourceType::CommandBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Texture",SWIG_From_int(static_cast< int >(ResourceType::Texture)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Buffer",SWIG_From_int(static_cast< int >(ResourceType::Buffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "View",SWIG_From_int(static_cast< int >(ResourceType::View)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Sampler",SWIG_From_int(static_cast< int >(ResourceType::Sampler)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SwapchainImage",SWIG_From_int(static_cast< int >(ResourceType::SwapchainImage)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Memory",SWIG_From_int(static_cast< int >(ResourceType::Memory)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Shader",SWIG_From_int(static_cast< int >(ResourceType::Shader)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ShaderBinding",SWIG_From_int(static_cast< int >(ResourceType::ShaderBinding)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PipelineState",SWIG_From_int(static_cast< int >(ResourceType::PipelineState)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "StateObject",SWIG_From_int(static_cast< int >(ResourceType::StateObject)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RenderPass",SWIG_From_int(static_cast< int >(ResourceType::RenderPass)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Query",SWIG_From_int(static_cast< int >(ResourceType::Query)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Sync",SWIG_From_int(static_cast< int >(ResourceType::Sync)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Pool",SWIG_From_int(static_cast< int >(ResourceType::Pool)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AccelerationStructure",SWIG_From_int(static_cast< int >(ResourceType::AccelerationStructure)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DescriptorStore",SWIG_From_int(static_cast< int >(ResourceType::DescriptorStore)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ResourceType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ResourceType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ResourceType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ResourceType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ResourceType");
  d = md;
  
  /* type '::TextureType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TextureType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(TextureType::Unknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "First",SWIG_From_int(static_cast< int >(TextureType::First)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Buffer",SWIG_From_int(static_cast< int >(TextureType::Buffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Texture1D",SWIG_From_int(static_cast< int >(TextureType::Texture1D)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Texture1DArray",SWIG_From_int(static_cast< int >(TextureType::Texture1DArray)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Texture2D",SWIG_From_int(static_cast< int >(TextureType::Texture2D)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TextureRect",SWIG_From_int(static_cast< int >(TextureType::TextureRect)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Texture2DArray",SWIG_From_int(static_cast< int >(TextureType::Texture2DArray)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Texture2DMS",SWIG_From_int(static_cast< int >(TextureType::Texture2DMS)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Texture2DMSArray",SWIG_From_int(static_cast< int >(TextureType::Texture2DMSArray)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Texture3D",SWIG_From_int(static_cast< int >(TextureType::Texture3D)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TextureCube",SWIG_From_int(static_cast< int >(TextureType::TextureCube)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TextureCubeArray",SWIG_From_int(static_cast< int >(TextureType::TextureCubeArray)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Count",SWIG_From_int(static_cast< int >(TextureType::Count)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "TextureType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "TextureType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'TextureType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "TextureType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TextureType");
  d = md;
  
  /* type '::BindType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__BindType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(BindType::Unknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ConstantBuffer",SWIG_From_int(static_cast< int >(BindType::ConstantBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Sampler",SWIG_From_int(static_cast< int >(BindType::Sampler)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ImageSampler",SWIG_From_int(static_cast< int >(BindType::ImageSampler)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadOnlyImage",SWIG_From_int(static_cast< int >(BindType::ReadOnlyImage)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadWriteImage",SWIG_From_int(static_cast< int >(BindType::ReadWriteImage)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadOnlyTBuffer",SWIG_From_int(static_cast< int >(BindType::ReadOnlyTBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadWriteTBuffer",SWIG_From_int(static_cast< int >(BindType::ReadWriteTBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadOnlyBuffer",SWIG_From_int(static_cast< int >(BindType::ReadOnlyBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadWriteBuffer",SWIG_From_int(static_cast< int >(BindType::ReadWriteBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadOnlyResource",SWIG_From_int(static_cast< int >(BindType::ReadOnlyResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadWriteResource",SWIG_From_int(static_cast< int >(BindType::ReadWriteResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InputAttachment",SWIG_From_int(static_cast< int >(BindType::InputAttachment)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "BindType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "BindType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'BindType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "BindType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "BindType");
  d = md;
  
  /* type '::DescriptorType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DescriptorType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(DescriptorType::Unknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ConstantBuffer",SWIG_From_int(static_cast< int >(DescriptorType::ConstantBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Sampler",SWIG_From_int(static_cast< int >(DescriptorType::Sampler)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ImageSampler",SWIG_From_int(static_cast< int >(DescriptorType::ImageSampler)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Image",SWIG_From_int(static_cast< int >(DescriptorType::Image)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Buffer",SWIG_From_int(static_cast< int >(DescriptorType::Buffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TypedBuffer",SWIG_From_int(static_cast< int >(DescriptorType::TypedBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadWriteImage",SWIG_From_int(static_cast< int >(DescriptorType::ReadWriteImage)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadWriteTypedBuffer",SWIG_From_int(static_cast< int >(DescriptorType::ReadWriteTypedBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadWriteBuffer",SWIG_From_int(static_cast< int >(DescriptorType::ReadWriteBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AccelerationStructure",SWIG_From_int(static_cast< int >(DescriptorType::AccelerationStructure)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "DescriptorType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "DescriptorType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'DescriptorType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "DescriptorType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DescriptorType");
  d = md;
  
  /* type '::DescriptorCategory' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DescriptorCategory_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(DescriptorCategory::Unknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ConstantBlock",SWIG_From_int(static_cast< int >(DescriptorCategory::ConstantBlock)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Sampler",SWIG_From_int(static_cast< int >(DescriptorCategory::Sampler)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadOnlyResource",SWIG_From_int(static_cast< int >(DescriptorCategory::ReadOnlyResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadWriteResource",SWIG_From_int(static_cast< int >(DescriptorCategory::ReadWriteResource)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "DescriptorCategory", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "DescriptorCategory", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'DescriptorCategory'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "DescriptorCategory", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DescriptorCategory");
  d = md;
  
  /* type '::ShaderBuiltin' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderBuiltin_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Undefined",SWIG_From_int(static_cast< int >(ShaderBuiltin::Undefined)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "First",SWIG_From_int(static_cast< int >(ShaderBuiltin::First)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Position",SWIG_From_int(static_cast< int >(ShaderBuiltin::Position)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PointSize",SWIG_From_int(static_cast< int >(ShaderBuiltin::PointSize)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ClipDistance",SWIG_From_int(static_cast< int >(ShaderBuiltin::ClipDistance)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CullDistance",SWIG_From_int(static_cast< int >(ShaderBuiltin::CullDistance)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RTIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::RTIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ViewportIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::ViewportIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "VertexIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::VertexIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PrimitiveIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::PrimitiveIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InstanceIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::InstanceIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DispatchSize",SWIG_From_int(static_cast< int >(ShaderBuiltin::DispatchSize)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DispatchThreadIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::DispatchThreadIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GroupIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::GroupIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GroupSize",SWIG_From_int(static_cast< int >(ShaderBuiltin::GroupSize)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GroupFlatIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::GroupFlatIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GroupThreadIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::GroupThreadIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GSInstanceIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::GSInstanceIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "OutputControlPointIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::OutputControlPointIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DomainLocation",SWIG_From_int(static_cast< int >(ShaderBuiltin::DomainLocation)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "IsFrontFace",SWIG_From_int(static_cast< int >(ShaderBuiltin::IsFrontFace)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MSAACoverage",SWIG_From_int(static_cast< int >(ShaderBuiltin::MSAACoverage)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MSAASamplePosition",SWIG_From_int(static_cast< int >(ShaderBuiltin::MSAASamplePosition)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MSAASampleIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::MSAASampleIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchNumVertices",SWIG_From_int(static_cast< int >(ShaderBuiltin::PatchNumVertices)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "OuterTessFactor",SWIG_From_int(static_cast< int >(ShaderBuiltin::OuterTessFactor)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InsideTessFactor",SWIG_From_int(static_cast< int >(ShaderBuiltin::InsideTessFactor)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ColorOutput",SWIG_From_int(static_cast< int >(ShaderBuiltin::ColorOutput)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DepthOutput",SWIG_From_int(static_cast< int >(ShaderBuiltin::DepthOutput)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DepthOutputGreaterEqual",SWIG_From_int(static_cast< int >(ShaderBuiltin::DepthOutputGreaterEqual)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DepthOutputLessEqual",SWIG_From_int(static_cast< int >(ShaderBuiltin::DepthOutputLessEqual)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BaseVertex",SWIG_From_int(static_cast< int >(ShaderBuiltin::BaseVertex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BaseInstance",SWIG_From_int(static_cast< int >(ShaderBuiltin::BaseInstance)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DrawIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::DrawIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "StencilReference",SWIG_From_int(static_cast< int >(ShaderBuiltin::StencilReference)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PointCoord",SWIG_From_int(static_cast< int >(ShaderBuiltin::PointCoord)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "IsHelper",SWIG_From_int(static_cast< int >(ShaderBuiltin::IsHelper)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SubgroupSize",SWIG_From_int(static_cast< int >(ShaderBuiltin::SubgroupSize)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NumSubgroups",SWIG_From_int(static_cast< int >(ShaderBuiltin::NumSubgroups)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SubgroupIndexInWorkgroup",SWIG_From_int(static_cast< int >(ShaderBuiltin::SubgroupIndexInWorkgroup)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "IndexInSubgroup",SWIG_From_int(static_cast< int >(ShaderBuiltin::IndexInSubgroup)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SubgroupEqualMask",SWIG_From_int(static_cast< int >(ShaderBuiltin::SubgroupEqualMask)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SubgroupGreaterEqualMask",SWIG_From_int(static_cast< int >(ShaderBuiltin::SubgroupGreaterEqualMask)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SubgroupGreaterMask",SWIG_From_int(static_cast< int >(ShaderBuiltin::SubgroupGreaterMask)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SubgroupLessEqualMask",SWIG_From_int(static_cast< int >(ShaderBuiltin::SubgroupLessEqualMask)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SubgroupLessMask",SWIG_From_int(static_cast< int >(ShaderBuiltin::SubgroupLessMask)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DeviceIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::DeviceIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "IsFullyCovered",SWIG_From_int(static_cast< int >(ShaderBuiltin::IsFullyCovered)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FragAreaSize",SWIG_From_int(static_cast< int >(ShaderBuiltin::FragAreaSize)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FragInvocationCount",SWIG_From_int(static_cast< int >(ShaderBuiltin::FragInvocationCount)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PackedFragRate",SWIG_From_int(static_cast< int >(ShaderBuiltin::PackedFragRate)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Barycentrics",SWIG_From_int(static_cast< int >(ShaderBuiltin::Barycentrics)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CullPrimitive",SWIG_From_int(static_cast< int >(ShaderBuiltin::CullPrimitive)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "OutputIndices",SWIG_From_int(static_cast< int >(ShaderBuiltin::OutputIndices)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MultiViewIndex",SWIG_From_int(static_cast< int >(ShaderBuiltin::MultiViewIndex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Count",SWIG_From_int(static_cast< int >(ShaderBuiltin::Count)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ShaderBuiltin", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ShaderBuiltin", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderBuiltin'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ShaderBuiltin", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderBuiltin");
  d = md;
  
  /* type '::ReplayOutputType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ReplayOutputType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Headless",SWIG_From_int(static_cast< int >(ReplayOutputType::Headless)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Texture",SWIG_From_int(static_cast< int >(ReplayOutputType::Texture)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Mesh",SWIG_From_int(static_cast< int >(ReplayOutputType::Mesh)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ReplayOutputType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ReplayOutputType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ReplayOutputType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ReplayOutputType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ReplayOutputType");
  d = md;
  
  /* type '::MeshDataStage' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__MeshDataStage_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "VSIn",SWIG_From_int(static_cast< int >(MeshDataStage::VSIn)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "First",SWIG_From_int(static_cast< int >(MeshDataStage::First)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "VSOut",SWIG_From_int(static_cast< int >(MeshDataStage::VSOut)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GSOut",SWIG_From_int(static_cast< int >(MeshDataStage::GSOut)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TaskOut",SWIG_From_int(static_cast< int >(MeshDataStage::TaskOut)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AmpOut",SWIG_From_int(static_cast< int >(MeshDataStage::AmpOut)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MeshOut",SWIG_From_int(static_cast< int >(MeshDataStage::MeshOut)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Count",SWIG_From_int(static_cast< int >(MeshDataStage::Count)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "MeshDataStage", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "MeshDataStage", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'MeshDataStage'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "MeshDataStage", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "MeshDataStage");
  d = md;
  
  /* type '::DebugOverlay' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DebugOverlay_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoOverlay",SWIG_From_int(static_cast< int >(DebugOverlay::NoOverlay)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Drawcall",SWIG_From_int(static_cast< int >(DebugOverlay::Drawcall)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Wireframe",SWIG_From_int(static_cast< int >(DebugOverlay::Wireframe)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Depth",SWIG_From_int(static_cast< int >(DebugOverlay::Depth)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Stencil",SWIG_From_int(static_cast< int >(DebugOverlay::Stencil)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BackfaceCull",SWIG_From_int(static_cast< int >(DebugOverlay::BackfaceCull)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ViewportScissor",SWIG_From_int(static_cast< int >(DebugOverlay::ViewportScissor)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NaN",SWIG_From_int(static_cast< int >(DebugOverlay::NaN)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Clipping",SWIG_From_int(static_cast< int >(DebugOverlay::Clipping)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ClearBeforePass",SWIG_From_int(static_cast< int >(DebugOverlay::ClearBeforePass)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ClearBeforeDraw",SWIG_From_int(static_cast< int >(DebugOverlay::ClearBeforeDraw)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "QuadOverdrawPass",SWIG_From_int(static_cast< int >(DebugOverlay::QuadOverdrawPass)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "QuadOverdrawDraw",SWIG_From_int(static_cast< int >(DebugOverlay::QuadOverdrawDraw)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TriangleSizePass",SWIG_From_int(static_cast< int >(DebugOverlay::TriangleSizePass)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TriangleSizeDraw",SWIG_From_int(static_cast< int >(DebugOverlay::TriangleSizeDraw)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "DebugOverlay", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "DebugOverlay", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'DebugOverlay'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "DebugOverlay", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DebugOverlay");
  d = md;
  
  /* type '::FileType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__FileType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DDS",SWIG_From_int(static_cast< int >(FileType::DDS)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "First",SWIG_From_int(static_cast< int >(FileType::First)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PNG",SWIG_From_int(static_cast< int >(FileType::PNG)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "JPG",SWIG_From_int(static_cast< int >(FileType::JPG)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BMP",SWIG_From_int(static_cast< int >(FileType::BMP)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TGA",SWIG_From_int(static_cast< int >(FileType::TGA)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "HDR",SWIG_From_int(static_cast< int >(FileType::HDR)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "EXR",SWIG_From_int(static_cast< int >(FileType::EXR)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Raw",SWIG_From_int(static_cast< int >(FileType::Raw)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Count",SWIG_From_int(static_cast< int >(FileType::Count)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "FileType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "FileType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'FileType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "FileType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "FileType");
  d = md;
  
  /* type '::AlphaMapping' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__AlphaMapping_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Discard",SWIG_From_int(static_cast< int >(AlphaMapping::Discard)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "First",SWIG_From_int(static_cast< int >(AlphaMapping::First)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BlendToColor",SWIG_From_int(static_cast< int >(AlphaMapping::BlendToColor)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BlendToCheckerboard",SWIG_From_int(static_cast< int >(AlphaMapping::BlendToCheckerboard)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Preserve",SWIG_From_int(static_cast< int >(AlphaMapping::Preserve)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Count",SWIG_From_int(static_cast< int >(AlphaMapping::Count)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "AlphaMapping", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "AlphaMapping", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'AlphaMapping'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "AlphaMapping", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "AlphaMapping");
  d = md;
  
  /* type '::ResourceFormatType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ResourceFormatType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Regular",SWIG_From_int(static_cast< int >(ResourceFormatType::Regular)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Undefined",SWIG_From_int(static_cast< int >(ResourceFormatType::Undefined)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BC1",SWIG_From_int(static_cast< int >(ResourceFormatType::BC1)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BC2",SWIG_From_int(static_cast< int >(ResourceFormatType::BC2)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BC3",SWIG_From_int(static_cast< int >(ResourceFormatType::BC3)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BC4",SWIG_From_int(static_cast< int >(ResourceFormatType::BC4)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BC5",SWIG_From_int(static_cast< int >(ResourceFormatType::BC5)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BC6",SWIG_From_int(static_cast< int >(ResourceFormatType::BC6)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BC7",SWIG_From_int(static_cast< int >(ResourceFormatType::BC7)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ETC2",SWIG_From_int(static_cast< int >(ResourceFormatType::ETC2)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "EAC",SWIG_From_int(static_cast< int >(ResourceFormatType::EAC)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ASTC",SWIG_From_int(static_cast< int >(ResourceFormatType::ASTC)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "R10G10B10A2",SWIG_From_int(static_cast< int >(ResourceFormatType::R10G10B10A2)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "R11G11B10",SWIG_From_int(static_cast< int >(ResourceFormatType::R11G11B10)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "R5G6B5",SWIG_From_int(static_cast< int >(ResourceFormatType::R5G6B5)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "R5G5B5A1",SWIG_From_int(static_cast< int >(ResourceFormatType::R5G5B5A1)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "R9G9B9E5",SWIG_From_int(static_cast< int >(ResourceFormatType::R9G9B9E5)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "R4G4B4A4",SWIG_From_int(static_cast< int >(ResourceFormatType::R4G4B4A4)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "R4G4",SWIG_From_int(static_cast< int >(ResourceFormatType::R4G4)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "D16S8",SWIG_From_int(static_cast< int >(ResourceFormatType::D16S8)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "D24S8",SWIG_From_int(static_cast< int >(ResourceFormatType::D24S8)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "D32S8",SWIG_From_int(static_cast< int >(ResourceFormatType::D32S8)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "S8",SWIG_From_int(static_cast< int >(ResourceFormatType::S8)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "YUV8",SWIG_From_int(static_cast< int >(ResourceFormatType::YUV8)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "YUV10",SWIG_From_int(static_cast< int >(ResourceFormatType::YUV10)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "YUV12",SWIG_From_int(static_cast< int >(ResourceFormatType::YUV12)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "YUV16",SWIG_From_int(static_cast< int >(ResourceFormatType::YUV16)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PVRTC",SWIG_From_int(static_cast< int >(ResourceFormatType::PVRTC)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "A8",SWIG_From_int(static_cast< int >(ResourceFormatType::A8)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ResourceFormatType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ResourceFormatType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ResourceFormatType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ResourceFormatType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ResourceFormatType");
  d = md;
  
  /* type '::QualityHint' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__QualityHint_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DontCare",SWIG_From_int(static_cast< int >(QualityHint::DontCare)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Nicest",SWIG_From_int(static_cast< int >(QualityHint::Nicest)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Fastest",SWIG_From_int(static_cast< int >(QualityHint::Fastest)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "QualityHint", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "QualityHint", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'QualityHint'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "QualityHint", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "QualityHint");
  d = md;
  
  /* type '::GPUVendor' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GPUVendor_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(GPUVendor::Unknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ARM",SWIG_From_int(static_cast< int >(GPUVendor::ARM)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AMD",SWIG_From_int(static_cast< int >(GPUVendor::AMD)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Broadcom",SWIG_From_int(static_cast< int >(GPUVendor::Broadcom)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Imagination",SWIG_From_int(static_cast< int >(GPUVendor::Imagination)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Intel",SWIG_From_int(static_cast< int >(GPUVendor::Intel)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "nVidia",SWIG_From_int(static_cast< int >(GPUVendor::nVidia)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Qualcomm",SWIG_From_int(static_cast< int >(GPUVendor::Qualcomm)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Verisilicon",SWIG_From_int(static_cast< int >(GPUVendor::Verisilicon)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Software",SWIG_From_int(static_cast< int >(GPUVendor::Software)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Samsung",SWIG_From_int(static_cast< int >(GPUVendor::Samsung)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "GPUVendor", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "GPUVendor", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'GPUVendor'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "GPUVendor", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GPUVendor");
  d = md;
  
  /* type '::GraphicsAPI' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GraphicsAPI_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "D3D11",SWIG_From_int(static_cast< int >(GraphicsAPI::D3D11)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "D3D12",SWIG_From_int(static_cast< int >(GraphicsAPI::D3D12)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "OpenGL",SWIG_From_int(static_cast< int >(GraphicsAPI::OpenGL)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Vulkan",SWIG_From_int(static_cast< int >(GraphicsAPI::Vulkan)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "GraphicsAPI", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "GraphicsAPI", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'GraphicsAPI'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "GraphicsAPI", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GraphicsAPI");
  d = md;
  
  /* type '::ShaderEncoding' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderEncoding_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(ShaderEncoding::Unknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "First",SWIG_From_int(static_cast< int >(ShaderEncoding::First)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DXBC",SWIG_From_int(static_cast< int >(ShaderEncoding::DXBC)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GLSL",SWIG_From_int(static_cast< int >(ShaderEncoding::GLSL)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SPIRV",SWIG_From_int(static_cast< int >(ShaderEncoding::SPIRV)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SPIRVAsm",SWIG_From_int(static_cast< int >(ShaderEncoding::SPIRVAsm)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "HLSL",SWIG_From_int(static_cast< int >(ShaderEncoding::HLSL)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DXIL",SWIG_From_int(static_cast< int >(ShaderEncoding::DXIL)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "OpenGLSPIRV",SWIG_From_int(static_cast< int >(ShaderEncoding::OpenGLSPIRV)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "OpenGLSPIRVAsm",SWIG_From_int(static_cast< int >(ShaderEncoding::OpenGLSPIRVAsm)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Slang",SWIG_From_int(static_cast< int >(ShaderEncoding::Slang)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Count",SWIG_From_int(static_cast< int >(ShaderEncoding::Count)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ShaderEncoding", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ShaderEncoding", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderEncoding'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ShaderEncoding", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderEncoding");
  d = md;
  
  /* type '::KnownShaderTool' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__KnownShaderTool_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(KnownShaderTool::Unknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "First",SWIG_From_int(static_cast< int >(KnownShaderTool::First)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SPIRV_Cross",SWIG_From_int(static_cast< int >(KnownShaderTool::SPIRV_Cross)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "spirv_dis",SWIG_From_int(static_cast< int >(KnownShaderTool::spirv_dis)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "glslangValidatorGLSL",SWIG_From_int(static_cast< int >(KnownShaderTool::glslangValidatorGLSL)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "glslangValidatorHLSL",SWIG_From_int(static_cast< int >(KnownShaderTool::glslangValidatorHLSL)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "spirv_as",SWIG_From_int(static_cast< int >(KnownShaderTool::spirv_as)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "dxcSPIRV",SWIG_From_int(static_cast< int >(KnownShaderTool::dxcSPIRV)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "dxcDXIL",SWIG_From_int(static_cast< int >(KnownShaderTool::dxcDXIL)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "fxc",SWIG_From_int(static_cast< int >(KnownShaderTool::fxc)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "glslangValidatorGLSL_OpenGL",SWIG_From_int(static_cast< int >(KnownShaderTool::glslangValidatorGLSL_OpenGL)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SPIRV_Cross_OpenGL",SWIG_From_int(static_cast< int >(KnownShaderTool::SPIRV_Cross_OpenGL)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "spirv_as_OpenGL",SWIG_From_int(static_cast< int >(KnownShaderTool::spirv_as_OpenGL)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "spirv_dis_OpenGL",SWIG_From_int(static_cast< int >(KnownShaderTool::spirv_dis_OpenGL)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "slangSPIRV",SWIG_From_int(static_cast< int >(KnownShaderTool::slangSPIRV)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "slangDXIL",SWIG_From_int(static_cast< int >(KnownShaderTool::slangDXIL)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Count",SWIG_From_int(static_cast< int >(KnownShaderTool::Count)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "KnownShaderTool", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "KnownShaderTool", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'KnownShaderTool'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "KnownShaderTool", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "KnownShaderTool");
  d = md;
  
  /* type '::Topology' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__Topology_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(Topology::Unknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PointList",SWIG_From_int(static_cast< int >(Topology::PointList)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "LineList",SWIG_From_int(static_cast< int >(Topology::LineList)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "LineStrip",SWIG_From_int(static_cast< int >(Topology::LineStrip)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "LineLoop",SWIG_From_int(static_cast< int >(Topology::LineLoop)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TriangleList",SWIG_From_int(static_cast< int >(Topology::TriangleList)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TriangleStrip",SWIG_From_int(static_cast< int >(Topology::TriangleStrip)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TriangleFan",SWIG_From_int(static_cast< int >(Topology::TriangleFan)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "LineList_Adj",SWIG_From_int(static_cast< int >(Topology::LineList_Adj)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "LineStrip_Adj",SWIG_From_int(static_cast< int >(Topology::LineStrip_Adj)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TriangleList_Adj",SWIG_From_int(static_cast< int >(Topology::TriangleList_Adj)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TriangleStrip_Adj",SWIG_From_int(static_cast< int >(Topology::TriangleStrip_Adj)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList",SWIG_From_int(static_cast< int >(Topology::PatchList)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_1CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_1CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_2CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_2CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_3CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_3CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_4CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_4CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_5CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_5CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_6CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_6CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_7CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_7CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_8CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_8CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_9CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_9CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_10CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_10CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_11CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_11CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_12CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_12CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_13CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_13CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_14CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_14CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_15CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_15CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_16CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_16CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_17CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_17CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_18CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_18CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_19CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_19CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_20CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_20CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_21CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_21CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_22CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_22CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_23CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_23CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_24CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_24CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_25CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_25CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_26CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_26CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_27CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_27CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_28CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_28CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_29CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_29CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_30CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_30CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_31CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_31CPs)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PatchList_32CPs",SWIG_From_int(static_cast< int >(Topology::PatchList_32CPs)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "Topology", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "Topology", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'Topology'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "Topology", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "Topology");
  d = md;
  
  /* type '::ShaderStage' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderStage_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Vertex",SWIG_From_int(static_cast< int >(ShaderStage::Vertex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "First",SWIG_From_int(static_cast< int >(ShaderStage::First)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Hull",SWIG_From_int(static_cast< int >(ShaderStage::Hull)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Tess_Control",SWIG_From_int(static_cast< int >(ShaderStage::Tess_Control)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Domain",SWIG_From_int(static_cast< int >(ShaderStage::Domain)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Tess_Eval",SWIG_From_int(static_cast< int >(ShaderStage::Tess_Eval)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Geometry",SWIG_From_int(static_cast< int >(ShaderStage::Geometry)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Pixel",SWIG_From_int(static_cast< int >(ShaderStage::Pixel)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Fragment",SWIG_From_int(static_cast< int >(ShaderStage::Fragment)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Compute",SWIG_From_int(static_cast< int >(ShaderStage::Compute)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Task",SWIG_From_int(static_cast< int >(ShaderStage::Task)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Amplification",SWIG_From_int(static_cast< int >(ShaderStage::Amplification)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Mesh",SWIG_From_int(static_cast< int >(ShaderStage::Mesh)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RayGen",SWIG_From_int(static_cast< int >(ShaderStage::RayGen)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Intersection",SWIG_From_int(static_cast< int >(ShaderStage::Intersection)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AnyHit",SWIG_From_int(static_cast< int >(ShaderStage::AnyHit)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ClosestHit",SWIG_From_int(static_cast< int >(ShaderStage::ClosestHit)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Miss",SWIG_From_int(static_cast< int >(ShaderStage::Miss)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Callable",SWIG_From_int(static_cast< int >(ShaderStage::Callable)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Count",SWIG_From_int(static_cast< int >(ShaderStage::Count)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ShaderStage", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ShaderStage", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderStage'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ShaderStage", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderStage");
  d = md;
  
  /* type '::MessageCategory' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__MessageCategory_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Application_Defined",SWIG_From_int(static_cast< int >(MessageCategory::Application_Defined)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Miscellaneous",SWIG_From_int(static_cast< int >(MessageCategory::Miscellaneous)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Initialization",SWIG_From_int(static_cast< int >(MessageCategory::Initialization)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Cleanup",SWIG_From_int(static_cast< int >(MessageCategory::Cleanup)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Compilation",SWIG_From_int(static_cast< int >(MessageCategory::Compilation)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "State_Creation",SWIG_From_int(static_cast< int >(MessageCategory::State_Creation)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "State_Setting",SWIG_From_int(static_cast< int >(MessageCategory::State_Setting)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "State_Getting",SWIG_From_int(static_cast< int >(MessageCategory::State_Getting)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Resource_Manipulation",SWIG_From_int(static_cast< int >(MessageCategory::Resource_Manipulation)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Execution",SWIG_From_int(static_cast< int >(MessageCategory::Execution)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Shaders",SWIG_From_int(static_cast< int >(MessageCategory::Shaders)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Deprecated",SWIG_From_int(static_cast< int >(MessageCategory::Deprecated)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Undefined",SWIG_From_int(static_cast< int >(MessageCategory::Undefined)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Portability",SWIG_From_int(static_cast< int >(MessageCategory::Portability)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Performance",SWIG_From_int(static_cast< int >(MessageCategory::Performance)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "MessageCategory", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "MessageCategory", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'MessageCategory'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "MessageCategory", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "MessageCategory");
  d = md;
  
  /* type '::MessageSeverity' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__MessageSeverity_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "High",SWIG_From_int(static_cast< int >(MessageSeverity::High)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Medium",SWIG_From_int(static_cast< int >(MessageSeverity::Medium)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Low",SWIG_From_int(static_cast< int >(MessageSeverity::Low)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Info",SWIG_From_int(static_cast< int >(MessageSeverity::Info)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "MessageSeverity", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "MessageSeverity", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'MessageSeverity'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "MessageSeverity", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "MessageSeverity");
  d = md;
  
  /* type '::MessageSource' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__MessageSource_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "API",SWIG_From_int(static_cast< int >(MessageSource::API)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RedundantAPIUse",SWIG_From_int(static_cast< int >(MessageSource::RedundantAPIUse)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "IncorrectAPIUse",SWIG_From_int(static_cast< int >(MessageSource::IncorrectAPIUse)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GeneralPerformance",SWIG_From_int(static_cast< int >(MessageSource::GeneralPerformance)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GCNPerformance",SWIG_From_int(static_cast< int >(MessageSource::GCNPerformance)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RuntimeWarning",SWIG_From_int(static_cast< int >(MessageSource::RuntimeWarning)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "UnsupportedConfiguration",SWIG_From_int(static_cast< int >(MessageSource::UnsupportedConfiguration)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "MessageSource", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "MessageSource", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'MessageSource'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "MessageSource", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "MessageSource");
  d = md;
  
  /* type '::ResourceUsage' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ResourceUsage_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unused",SWIG_From_int(static_cast< int >(ResourceUsage::Unused)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "VertexBuffer",SWIG_From_int(static_cast< int >(ResourceUsage::VertexBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "IndexBuffer",SWIG_From_int(static_cast< int >(ResourceUsage::IndexBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "VS_Constants",SWIG_From_int(static_cast< int >(ResourceUsage::VS_Constants)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "HS_Constants",SWIG_From_int(static_cast< int >(ResourceUsage::HS_Constants)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DS_Constants",SWIG_From_int(static_cast< int >(ResourceUsage::DS_Constants)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GS_Constants",SWIG_From_int(static_cast< int >(ResourceUsage::GS_Constants)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PS_Constants",SWIG_From_int(static_cast< int >(ResourceUsage::PS_Constants)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CS_Constants",SWIG_From_int(static_cast< int >(ResourceUsage::CS_Constants)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TS_Constants",SWIG_From_int(static_cast< int >(ResourceUsage::TS_Constants)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MS_Constants",SWIG_From_int(static_cast< int >(ResourceUsage::MS_Constants)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "All_Constants",SWIG_From_int(static_cast< int >(ResourceUsage::All_Constants)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "StreamOut",SWIG_From_int(static_cast< int >(ResourceUsage::StreamOut)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "VS_Resource",SWIG_From_int(static_cast< int >(ResourceUsage::VS_Resource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "HS_Resource",SWIG_From_int(static_cast< int >(ResourceUsage::HS_Resource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DS_Resource",SWIG_From_int(static_cast< int >(ResourceUsage::DS_Resource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GS_Resource",SWIG_From_int(static_cast< int >(ResourceUsage::GS_Resource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PS_Resource",SWIG_From_int(static_cast< int >(ResourceUsage::PS_Resource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CS_Resource",SWIG_From_int(static_cast< int >(ResourceUsage::CS_Resource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TS_Resource",SWIG_From_int(static_cast< int >(ResourceUsage::TS_Resource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MS_Resource",SWIG_From_int(static_cast< int >(ResourceUsage::MS_Resource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "All_Resource",SWIG_From_int(static_cast< int >(ResourceUsage::All_Resource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "VS_RWResource",SWIG_From_int(static_cast< int >(ResourceUsage::VS_RWResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "HS_RWResource",SWIG_From_int(static_cast< int >(ResourceUsage::HS_RWResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DS_RWResource",SWIG_From_int(static_cast< int >(ResourceUsage::DS_RWResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GS_RWResource",SWIG_From_int(static_cast< int >(ResourceUsage::GS_RWResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PS_RWResource",SWIG_From_int(static_cast< int >(ResourceUsage::PS_RWResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CS_RWResource",SWIG_From_int(static_cast< int >(ResourceUsage::CS_RWResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TS_RWResource",SWIG_From_int(static_cast< int >(ResourceUsage::TS_RWResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MS_RWResource",SWIG_From_int(static_cast< int >(ResourceUsage::MS_RWResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "All_RWResource",SWIG_From_int(static_cast< int >(ResourceUsage::All_RWResource)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InputTarget",SWIG_From_int(static_cast< int >(ResourceUsage::InputTarget)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ColorTarget",SWIG_From_int(static_cast< int >(ResourceUsage::ColorTarget)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DepthStencilTarget",SWIG_From_int(static_cast< int >(ResourceUsage::DepthStencilTarget)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Indirect",SWIG_From_int(static_cast< int >(ResourceUsage::Indirect)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Clear",SWIG_From_int(static_cast< int >(ResourceUsage::Clear)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Discard",SWIG_From_int(static_cast< int >(ResourceUsage::Discard)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GenMips",SWIG_From_int(static_cast< int >(ResourceUsage::GenMips)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Resolve",SWIG_From_int(static_cast< int >(ResourceUsage::Resolve)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ResolveSrc",SWIG_From_int(static_cast< int >(ResourceUsage::ResolveSrc)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ResolveDst",SWIG_From_int(static_cast< int >(ResourceUsage::ResolveDst)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Copy",SWIG_From_int(static_cast< int >(ResourceUsage::Copy)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CopySrc",SWIG_From_int(static_cast< int >(ResourceUsage::CopySrc)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CopyDst",SWIG_From_int(static_cast< int >(ResourceUsage::CopyDst)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Barrier",SWIG_From_int(static_cast< int >(ResourceUsage::Barrier)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CPUWrite",SWIG_From_int(static_cast< int >(ResourceUsage::CPUWrite)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ResourceUsage", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ResourceUsage", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ResourceUsage'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ResourceUsage", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ResourceUsage");
  d = md;
  
  /* type '::Visualisation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__Visualisation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoSolid",SWIG_From_int(static_cast< int >(Visualisation::NoSolid)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Solid",SWIG_From_int(static_cast< int >(Visualisation::Solid)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Lit",SWIG_From_int(static_cast< int >(Visualisation::Lit)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Secondary",SWIG_From_int(static_cast< int >(Visualisation::Secondary)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Explode",SWIG_From_int(static_cast< int >(Visualisation::Explode)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Meshlet",SWIG_From_int(static_cast< int >(Visualisation::Meshlet)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Count",SWIG_From_int(static_cast< int >(Visualisation::Count)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "Visualisation", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "Visualisation", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'Visualisation'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "Visualisation", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "Visualisation");
  d = md;
  
  /* type '::FillMode' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__FillMode_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Solid",SWIG_From_int(static_cast< int >(FillMode::Solid)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Wireframe",SWIG_From_int(static_cast< int >(FillMode::Wireframe)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Point",SWIG_From_int(static_cast< int >(FillMode::Point)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "FillMode", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "FillMode", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'FillMode'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "FillMode", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "FillMode");
  d = md;
  
  /* type '::CullMode' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CullMode_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoCull",SWIG_From_int(static_cast< int >(CullMode::NoCull)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Front",SWIG_From_int(static_cast< int >(CullMode::Front)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Back",SWIG_From_int(static_cast< int >(CullMode::Back)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FrontAndBack",SWIG_From_int(static_cast< int >(CullMode::FrontAndBack)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "CullMode", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "CullMode", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'CullMode'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "CullMode", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "CullMode");
  d = md;
  
  /* type '::ConservativeRaster' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ConservativeRaster_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Disabled",SWIG_From_int(static_cast< int >(ConservativeRaster::Disabled)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Underestimate",SWIG_From_int(static_cast< int >(ConservativeRaster::Underestimate)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Overestimate",SWIG_From_int(static_cast< int >(ConservativeRaster::Overestimate)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ConservativeRaster", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ConservativeRaster", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ConservativeRaster'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ConservativeRaster", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ConservativeRaster");
  d = md;
  
  /* type '::ShadingRateCombiner' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShadingRateCombiner_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Keep",SWIG_From_int(static_cast< int >(ShadingRateCombiner::Keep)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Passthrough",SWIG_From_int(static_cast< int >(ShadingRateCombiner::Passthrough)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Replace",SWIG_From_int(static_cast< int >(ShadingRateCombiner::Replace)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Override",SWIG_From_int(static_cast< int >(ShadingRateCombiner::Override)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Min",SWIG_From_int(static_cast< int >(ShadingRateCombiner::Min)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Max",SWIG_From_int(static_cast< int >(ShadingRateCombiner::Max)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Multiply",SWIG_From_int(static_cast< int >(ShadingRateCombiner::Multiply)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ShadingRateCombiner", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ShadingRateCombiner", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ShadingRateCombiner'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ShadingRateCombiner", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShadingRateCombiner");
  d = md;
  
  /* type '::LineRaster' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__LineRaster_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Default",SWIG_From_int(static_cast< int >(LineRaster::Default)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Rectangular",SWIG_From_int(static_cast< int >(LineRaster::Rectangular)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Bresenham",SWIG_From_int(static_cast< int >(LineRaster::Bresenham)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RectangularSmooth",SWIG_From_int(static_cast< int >(LineRaster::RectangularSmooth)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RectangularD3D",SWIG_From_int(static_cast< int >(LineRaster::RectangularD3D)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "LineRaster", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "LineRaster", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'LineRaster'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "LineRaster", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "LineRaster");
  d = md;
  
  /* type '::FilterMode' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__FilterMode_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoFilter",SWIG_From_int(static_cast< int >(FilterMode::NoFilter)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Point",SWIG_From_int(static_cast< int >(FilterMode::Point)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Linear",SWIG_From_int(static_cast< int >(FilterMode::Linear)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Cubic",SWIG_From_int(static_cast< int >(FilterMode::Cubic)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Anisotropic",SWIG_From_int(static_cast< int >(FilterMode::Anisotropic)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "FilterMode", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "FilterMode", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'FilterMode'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "FilterMode", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "FilterMode");
  d = md;
  
  /* type '::FilterFunction' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__FilterFunction_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Normal",SWIG_From_int(static_cast< int >(FilterFunction::Normal)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Comparison",SWIG_From_int(static_cast< int >(FilterFunction::Comparison)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Minimum",SWIG_From_int(static_cast< int >(FilterFunction::Minimum)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Maximum",SWIG_From_int(static_cast< int >(FilterFunction::Maximum)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "FilterFunction", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "FilterFunction", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'FilterFunction'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "FilterFunction", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "FilterFunction");
  d = md;
  
  /* type '::CompareFunction' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CompareFunction_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Never",SWIG_From_int(static_cast< int >(CompareFunction::Never)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AlwaysTrue",SWIG_From_int(static_cast< int >(CompareFunction::AlwaysTrue)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Less",SWIG_From_int(static_cast< int >(CompareFunction::Less)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "LessEqual",SWIG_From_int(static_cast< int >(CompareFunction::LessEqual)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Greater",SWIG_From_int(static_cast< int >(CompareFunction::Greater)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GreaterEqual",SWIG_From_int(static_cast< int >(CompareFunction::GreaterEqual)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Equal",SWIG_From_int(static_cast< int >(CompareFunction::Equal)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NotEqual",SWIG_From_int(static_cast< int >(CompareFunction::NotEqual)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "CompareFunction", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "CompareFunction", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'CompareFunction'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "CompareFunction", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "CompareFunction");
  d = md;
  
  /* type '::StencilOperation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__StencilOperation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Keep",SWIG_From_int(static_cast< int >(StencilOperation::Keep)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Zero",SWIG_From_int(static_cast< int >(StencilOperation::Zero)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Replace",SWIG_From_int(static_cast< int >(StencilOperation::Replace)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "IncSat",SWIG_From_int(static_cast< int >(StencilOperation::IncSat)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DecSat",SWIG_From_int(static_cast< int >(StencilOperation::DecSat)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "IncWrap",SWIG_From_int(static_cast< int >(StencilOperation::IncWrap)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DecWrap",SWIG_From_int(static_cast< int >(StencilOperation::DecWrap)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Invert",SWIG_From_int(static_cast< int >(StencilOperation::Invert)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "StencilOperation", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "StencilOperation", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'StencilOperation'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "StencilOperation", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "StencilOperation");
  d = md;
  
  /* type '::BlendMultiplier' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__BlendMultiplier_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Zero",SWIG_From_int(static_cast< int >(BlendMultiplier::Zero)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "One",SWIG_From_int(static_cast< int >(BlendMultiplier::One)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SrcCol",SWIG_From_int(static_cast< int >(BlendMultiplier::SrcCol)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InvSrcCol",SWIG_From_int(static_cast< int >(BlendMultiplier::InvSrcCol)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DstCol",SWIG_From_int(static_cast< int >(BlendMultiplier::DstCol)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InvDstCol",SWIG_From_int(static_cast< int >(BlendMultiplier::InvDstCol)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SrcAlpha",SWIG_From_int(static_cast< int >(BlendMultiplier::SrcAlpha)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InvSrcAlpha",SWIG_From_int(static_cast< int >(BlendMultiplier::InvSrcAlpha)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DstAlpha",SWIG_From_int(static_cast< int >(BlendMultiplier::DstAlpha)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InvDstAlpha",SWIG_From_int(static_cast< int >(BlendMultiplier::InvDstAlpha)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SrcAlphaSat",SWIG_From_int(static_cast< int >(BlendMultiplier::SrcAlphaSat)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FactorRGB",SWIG_From_int(static_cast< int >(BlendMultiplier::FactorRGB)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InvFactorRGB",SWIG_From_int(static_cast< int >(BlendMultiplier::InvFactorRGB)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FactorAlpha",SWIG_From_int(static_cast< int >(BlendMultiplier::FactorAlpha)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InvFactorAlpha",SWIG_From_int(static_cast< int >(BlendMultiplier::InvFactorAlpha)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Src1Col",SWIG_From_int(static_cast< int >(BlendMultiplier::Src1Col)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InvSrc1Col",SWIG_From_int(static_cast< int >(BlendMultiplier::InvSrc1Col)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Src1Alpha",SWIG_From_int(static_cast< int >(BlendMultiplier::Src1Alpha)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InvSrc1Alpha",SWIG_From_int(static_cast< int >(BlendMultiplier::InvSrc1Alpha)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "BlendMultiplier", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "BlendMultiplier", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'BlendMultiplier'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "BlendMultiplier", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "BlendMultiplier");
  d = md;
  
  /* type '::BlendOperation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__BlendOperation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Add",SWIG_From_int(static_cast< int >(BlendOperation::Add)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Subtract",SWIG_From_int(static_cast< int >(BlendOperation::Subtract)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReversedSubtract",SWIG_From_int(static_cast< int >(BlendOperation::ReversedSubtract)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Minimum",SWIG_From_int(static_cast< int >(BlendOperation::Minimum)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Maximum",SWIG_From_int(static_cast< int >(BlendOperation::Maximum)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "BlendOperation", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "BlendOperation", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'BlendOperation'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "BlendOperation", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "BlendOperation");
  d = md;
  
  /* type '::LogicOperation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__LogicOperation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoOp",SWIG_From_int(static_cast< int >(LogicOperation::NoOp)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Clear",SWIG_From_int(static_cast< int >(LogicOperation::Clear)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Set",SWIG_From_int(static_cast< int >(LogicOperation::Set)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Copy",SWIG_From_int(static_cast< int >(LogicOperation::Copy)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CopyInverted",SWIG_From_int(static_cast< int >(LogicOperation::CopyInverted)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Invert",SWIG_From_int(static_cast< int >(LogicOperation::Invert)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "And",SWIG_From_int(static_cast< int >(LogicOperation::And)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Nand",SWIG_From_int(static_cast< int >(LogicOperation::Nand)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Or",SWIG_From_int(static_cast< int >(LogicOperation::Or)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Xor",SWIG_From_int(static_cast< int >(LogicOperation::Xor)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Nor",SWIG_From_int(static_cast< int >(LogicOperation::Nor)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Equivalent",SWIG_From_int(static_cast< int >(LogicOperation::Equivalent)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AndReverse",SWIG_From_int(static_cast< int >(LogicOperation::AndReverse)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AndInverted",SWIG_From_int(static_cast< int >(LogicOperation::AndInverted)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "OrReverse",SWIG_From_int(static_cast< int >(LogicOperation::OrReverse)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "OrInverted",SWIG_From_int(static_cast< int >(LogicOperation::OrInverted)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "LogicOperation", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "LogicOperation", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'LogicOperation'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "LogicOperation", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "LogicOperation");
  d = md;
  
  /* type '::GPUCounter' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__GPUCounter_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "EventGPUDuration",SWIG_From_int(static_cast< int >(GPUCounter::EventGPUDuration)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "First",SWIG_From_int(static_cast< int >(GPUCounter::First)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InputVerticesRead",SWIG_From_int(static_cast< int >(GPUCounter::InputVerticesRead)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "IAPrimitives",SWIG_From_int(static_cast< int >(GPUCounter::IAPrimitives)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GSPrimitives",SWIG_From_int(static_cast< int >(GPUCounter::GSPrimitives)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RasterizerInvocations",SWIG_From_int(static_cast< int >(GPUCounter::RasterizerInvocations)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RasterizedPrimitives",SWIG_From_int(static_cast< int >(GPUCounter::RasterizedPrimitives)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SamplesPassed",SWIG_From_int(static_cast< int >(GPUCounter::SamplesPassed)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "VSInvocations",SWIG_From_int(static_cast< int >(GPUCounter::VSInvocations)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "HSInvocations",SWIG_From_int(static_cast< int >(GPUCounter::HSInvocations)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TCSInvocations",SWIG_From_int(static_cast< int >(GPUCounter::TCSInvocations)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DSInvocations",SWIG_From_int(static_cast< int >(GPUCounter::DSInvocations)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TESInvocations",SWIG_From_int(static_cast< int >(GPUCounter::TESInvocations)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GSInvocations",SWIG_From_int(static_cast< int >(GPUCounter::GSInvocations)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PSInvocations",SWIG_From_int(static_cast< int >(GPUCounter::PSInvocations)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FSInvocations",SWIG_From_int(static_cast< int >(GPUCounter::FSInvocations)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CSInvocations",SWIG_From_int(static_cast< int >(GPUCounter::CSInvocations)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ASInvocations",SWIG_From_int(static_cast< int >(GPUCounter::ASInvocations)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "TSInvocations",SWIG_From_int(static_cast< int >(GPUCounter::TSInvocations)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MSInvocations",SWIG_From_int(static_cast< int >(GPUCounter::MSInvocations)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Count",SWIG_From_int(static_cast< int >(GPUCounter::Count)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FirstAMD",SWIG_From_int(static_cast< int >(GPUCounter::FirstAMD)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FirstIntel",SWIG_From_int(static_cast< int >(GPUCounter::FirstIntel)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "LastAMD",SWIG_From_int(static_cast< int >(GPUCounter::LastAMD)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FirstNvidia",SWIG_From_int(static_cast< int >(GPUCounter::FirstNvidia)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "LastIntel",SWIG_From_int(static_cast< int >(GPUCounter::LastIntel)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FirstVulkanExtended",SWIG_From_int(static_cast< int >(GPUCounter::FirstVulkanExtended)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "LastNvidia",SWIG_From_int(static_cast< int >(GPUCounter::LastNvidia)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FirstARM",SWIG_From_int(static_cast< int >(GPUCounter::FirstARM)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "LastVulkanExtended",SWIG_From_int(static_cast< int >(GPUCounter::LastVulkanExtended)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "LastARM",SWIG_From_int(static_cast< int >(GPUCounter::LastARM)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "GPUCounter", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "GPUCounter", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'GPUCounter'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "GPUCounter", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "GPUCounter");
  d = md;
  
  /* type '::CounterUnit' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CounterUnit_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Absolute",SWIG_From_int(static_cast< int >(CounterUnit::Absolute)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Seconds",SWIG_From_int(static_cast< int >(CounterUnit::Seconds)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Percentage",SWIG_From_int(static_cast< int >(CounterUnit::Percentage)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Ratio",SWIG_From_int(static_cast< int >(CounterUnit::Ratio)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Bytes",SWIG_From_int(static_cast< int >(CounterUnit::Bytes)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Cycles",SWIG_From_int(static_cast< int >(CounterUnit::Cycles)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Hertz",SWIG_From_int(static_cast< int >(CounterUnit::Hertz)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Volt",SWIG_From_int(static_cast< int >(CounterUnit::Volt)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Celsius",SWIG_From_int(static_cast< int >(CounterUnit::Celsius)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "CounterUnit", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "CounterUnit", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'CounterUnit'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "CounterUnit", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "CounterUnit");
  d = md;
  
  /* type '::CameraType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__CameraType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Arcball",SWIG_From_int(static_cast< int >(CameraType::Arcball)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FPSLook",SWIG_From_int(static_cast< int >(CameraType::FPSLook)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "CameraType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "CameraType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'CameraType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "CameraType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "CameraType");
  d = md;
  
  /* type '::ReplaySupport' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ReplaySupport_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unsupported",SWIG_From_int(static_cast< int >(ReplaySupport::Unsupported)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Supported",SWIG_From_int(static_cast< int >(ReplaySupport::Supported)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SuggestRemote",SWIG_From_int(static_cast< int >(ReplaySupport::SuggestRemote)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ReplaySupport", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ReplaySupport", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ReplaySupport'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ReplaySupport", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ReplaySupport");
  d = md;
  
  /* type '::ResultCode' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ResultCode_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Succeeded",SWIG_From_int(static_cast< int >(ResultCode::Succeeded)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "UnknownError",SWIG_From_int(static_cast< int >(ResultCode::UnknownError)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InternalError",SWIG_From_int(static_cast< int >(ResultCode::InternalError)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FileNotFound",SWIG_From_int(static_cast< int >(ResultCode::FileNotFound)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InjectionFailed",SWIG_From_int(static_cast< int >(ResultCode::InjectionFailed)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "IncompatibleProcess",SWIG_From_int(static_cast< int >(ResultCode::IncompatibleProcess)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NetworkIOFailed",SWIG_From_int(static_cast< int >(ResultCode::NetworkIOFailed)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NetworkRemoteBusy",SWIG_From_int(static_cast< int >(ResultCode::NetworkRemoteBusy)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NetworkVersionMismatch",SWIG_From_int(static_cast< int >(ResultCode::NetworkVersionMismatch)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FileIOFailed",SWIG_From_int(static_cast< int >(ResultCode::FileIOFailed)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FileIncompatibleVersion",SWIG_From_int(static_cast< int >(ResultCode::FileIncompatibleVersion)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FileCorrupted",SWIG_From_int(static_cast< int >(ResultCode::FileCorrupted)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "FileUnrecognised",SWIG_From_int(static_cast< int >(ResultCode::FileUnrecognised)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ImageUnsupported",SWIG_From_int(static_cast< int >(ResultCode::ImageUnsupported)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "APIUnsupported",SWIG_From_int(static_cast< int >(ResultCode::APIUnsupported)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "APIInitFailed",SWIG_From_int(static_cast< int >(ResultCode::APIInitFailed)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "APIIncompatibleVersion",SWIG_From_int(static_cast< int >(ResultCode::APIIncompatibleVersion)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "APIHardwareUnsupported",SWIG_From_int(static_cast< int >(ResultCode::APIHardwareUnsupported)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "APIDataCorrupted",SWIG_From_int(static_cast< int >(ResultCode::APIDataCorrupted)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "APIReplayFailed",SWIG_From_int(static_cast< int >(ResultCode::APIReplayFailed)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "JDWPFailure",SWIG_From_int(static_cast< int >(ResultCode::JDWPFailure)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AndroidGrantPermissionsFailed",SWIG_From_int(static_cast< int >(ResultCode::AndroidGrantPermissionsFailed)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AndroidABINotFound",SWIG_From_int(static_cast< int >(ResultCode::AndroidABINotFound)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AndroidAPKFolderNotFound",SWIG_From_int(static_cast< int >(ResultCode::AndroidAPKFolderNotFound)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AndroidAPKInstallFailed",SWIG_From_int(static_cast< int >(ResultCode::AndroidAPKInstallFailed)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AndroidAPKVerifyFailed",SWIG_From_int(static_cast< int >(ResultCode::AndroidAPKVerifyFailed)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RemoteServerConnectionLost",SWIG_From_int(static_cast< int >(ResultCode::RemoteServerConnectionLost)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "OutOfMemory",SWIG_From_int(static_cast< int >(ResultCode::OutOfMemory)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DeviceLost",SWIG_From_int(static_cast< int >(ResultCode::DeviceLost)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DataNotAvailable",SWIG_From_int(static_cast< int >(ResultCode::DataNotAvailable)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InvalidParameter",SWIG_From_int(static_cast< int >(ResultCode::InvalidParameter)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CompressionFailed",SWIG_From_int(static_cast< int >(ResultCode::CompressionFailed)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AndroidLayerConfFailed",SWIG_From_int(static_cast< int >(ResultCode::AndroidLayerConfFailed)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ResultCode", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ResultCode", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ResultCode'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ResultCode", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ResultCode");
  d = md;
  
  /* type '::TargetControlMessageType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TargetControlMessageType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(TargetControlMessageType::Unknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Disconnected",SWIG_From_int(static_cast< int >(TargetControlMessageType::Disconnected)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Busy",SWIG_From_int(static_cast< int >(TargetControlMessageType::Busy)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Noop",SWIG_From_int(static_cast< int >(TargetControlMessageType::Noop)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NewCapture",SWIG_From_int(static_cast< int >(TargetControlMessageType::NewCapture)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CaptureCopied",SWIG_From_int(static_cast< int >(TargetControlMessageType::CaptureCopied)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RegisterAPI",SWIG_From_int(static_cast< int >(TargetControlMessageType::RegisterAPI)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NewChild",SWIG_From_int(static_cast< int >(TargetControlMessageType::NewChild)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CaptureProgress",SWIG_From_int(static_cast< int >(TargetControlMessageType::CaptureProgress)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CapturableWindowCount",SWIG_From_int(static_cast< int >(TargetControlMessageType::CapturableWindowCount)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RequestShow",SWIG_From_int(static_cast< int >(TargetControlMessageType::RequestShow)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "TargetControlMessageType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "TargetControlMessageType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'TargetControlMessageType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "TargetControlMessageType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TargetControlMessageType");
  d = md;
  
  /* type '::EnvMod' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__EnvMod_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Set",SWIG_From_int(static_cast< int >(EnvMod::Set)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Append",SWIG_From_int(static_cast< int >(EnvMod::Append)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Prepend",SWIG_From_int(static_cast< int >(EnvMod::Prepend)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "EnvMod", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "EnvMod", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'EnvMod'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "EnvMod", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "EnvMod");
  d = md;
  
  /* type '::EnvSep' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__EnvSep_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Platform",SWIG_From_int(static_cast< int >(EnvSep::Platform)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SemiColon",SWIG_From_int(static_cast< int >(EnvSep::SemiColon)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Colon",SWIG_From_int(static_cast< int >(EnvSep::Colon)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoSep",SWIG_From_int(static_cast< int >(EnvSep::NoSep)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "EnvSep", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "EnvSep", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'EnvSep'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "EnvSep", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "EnvSep");
  d = md;
  
  /* type '::LogType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__LogType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Debug",SWIG_From_int(static_cast< int >(LogType::Debug)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "First",SWIG_From_int(static_cast< int >(LogType::First)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Comment",SWIG_From_int(static_cast< int >(LogType::Comment)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Warning",SWIG_From_int(static_cast< int >(LogType::Warning)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Error",SWIG_From_int(static_cast< int >(LogType::Error)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Fatal",SWIG_From_int(static_cast< int >(LogType::Fatal)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Count",SWIG_From_int(static_cast< int >(LogType::Count)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "LogType", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "LogType", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'LogType'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "LogType", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "LogType");
  d = md;
  
  /* type '::ReplayOptimisationLevel' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ReplayOptimisationLevel_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoOptimisation",SWIG_From_int(static_cast< int >(ReplayOptimisationLevel::NoOptimisation)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "First",SWIG_From_int(static_cast< int >(ReplayOptimisationLevel::First)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Conservative",SWIG_From_int(static_cast< int >(ReplayOptimisationLevel::Conservative)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Balanced",SWIG_From_int(static_cast< int >(ReplayOptimisationLevel::Balanced)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Fastest",SWIG_From_int(static_cast< int >(ReplayOptimisationLevel::Fastest)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Count",SWIG_From_int(static_cast< int >(ReplayOptimisationLevel::Count)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ReplayOptimisationLevel", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ReplayOptimisationLevel", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ReplayOptimisationLevel'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ReplayOptimisationLevel", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ReplayOptimisationLevel");
  d = md;
  
  /* type '::WindowingSystem' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__WindowingSystem_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(WindowingSystem::Unknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Headless",SWIG_From_int(static_cast< int >(WindowingSystem::Headless)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Win32",SWIG_From_int(static_cast< int >(WindowingSystem::Win32)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Xlib",SWIG_From_int(static_cast< int >(WindowingSystem::Xlib)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "XCB",SWIG_From_int(static_cast< int >(WindowingSystem::XCB)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Android",SWIG_From_int(static_cast< int >(WindowingSystem::Android)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MacOS",SWIG_From_int(static_cast< int >(WindowingSystem::MacOS)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Wayland",SWIG_From_int(static_cast< int >(WindowingSystem::Wayland)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "WindowingSystem", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "WindowingSystem", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'WindowingSystem'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "WindowingSystem", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "WindowingSystem");
  d = md;
  
  /* type '::PathProperty' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__PathProperty_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoFlags",SWIG_From_int(static_cast< int >(PathProperty::NoFlags)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Directory",SWIG_From_int(static_cast< int >(PathProperty::Directory)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Hidden",SWIG_From_int(static_cast< int >(PathProperty::Hidden)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Executable",SWIG_From_int(static_cast< int >(PathProperty::Executable)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ErrorUnknown",SWIG_From_int(static_cast< int >(PathProperty::ErrorUnknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ErrorAccessDenied",SWIG_From_int(static_cast< int >(PathProperty::ErrorAccessDenied)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ErrorInvalidPath",SWIG_From_int(static_cast< int >(PathProperty::ErrorInvalidPath)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    if(Flag_class) constructor = Flag_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "PathProperty", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "PathProperty", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'PathProperty'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "PathProperty", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "PathProperty");
  d = md;
  
  /* type '::SectionFlags' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SectionFlags_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoFlags",SWIG_From_int(static_cast< int >(SectionFlags::NoFlags)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ASCIIStored",SWIG_From_int(static_cast< int >(SectionFlags::ASCIIStored)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "LZ4Compressed",SWIG_From_int(static_cast< int >(SectionFlags::LZ4Compressed)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ZstdCompressed",SWIG_From_int(static_cast< int >(SectionFlags::ZstdCompressed)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    if(Flag_class) constructor = Flag_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "SectionFlags", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "SectionFlags", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'SectionFlags'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "SectionFlags", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SectionFlags");
  d = md;
  
  /* type '::BufferCategory' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__BufferCategory_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoFlags",SWIG_From_int(static_cast< int >(BufferCategory::NoFlags)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Vertex",SWIG_From_int(static_cast< int >(BufferCategory::Vertex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Index",SWIG_From_int(static_cast< int >(BufferCategory::Index)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Constants",SWIG_From_int(static_cast< int >(BufferCategory::Constants)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadWrite",SWIG_From_int(static_cast< int >(BufferCategory::ReadWrite)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Indirect",SWIG_From_int(static_cast< int >(BufferCategory::Indirect)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    if(Flag_class) constructor = Flag_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "BufferCategory", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "BufferCategory", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'BufferCategory'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "BufferCategory", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "BufferCategory");
  d = md;
  
  /* type '::DescriptorFlags' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DescriptorFlags_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoFlags",SWIG_From_int(static_cast< int >(DescriptorFlags::NoFlags)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RawBuffer",SWIG_From_int(static_cast< int >(DescriptorFlags::RawBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AppendBuffer",SWIG_From_int(static_cast< int >(DescriptorFlags::AppendBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CounterBuffer",SWIG_From_int(static_cast< int >(DescriptorFlags::CounterBuffer)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ReadOnlyAccess",SWIG_From_int(static_cast< int >(DescriptorFlags::ReadOnlyAccess)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "WriteOnlyAccess",SWIG_From_int(static_cast< int >(DescriptorFlags::WriteOnlyAccess)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "InlineData",SWIG_From_int(static_cast< int >(DescriptorFlags::InlineData)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    if(Flag_class) constructor = Flag_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "DescriptorFlags", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "DescriptorFlags", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'DescriptorFlags'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "DescriptorFlags", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DescriptorFlags");
  d = md;
  
  /* type '::TextureCategory' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__TextureCategory_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoFlags",SWIG_From_int(static_cast< int >(TextureCategory::NoFlags)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ShaderRead",SWIG_From_int(static_cast< int >(TextureCategory::ShaderRead)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ColorTarget",SWIG_From_int(static_cast< int >(TextureCategory::ColorTarget)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DepthTarget",SWIG_From_int(static_cast< int >(TextureCategory::DepthTarget)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ShaderReadWrite",SWIG_From_int(static_cast< int >(TextureCategory::ShaderReadWrite)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SwapBuffer",SWIG_From_int(static_cast< int >(TextureCategory::SwapBuffer)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    if(Flag_class) constructor = Flag_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "TextureCategory", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "TextureCategory", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'TextureCategory'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "TextureCategory", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "TextureCategory");
  d = md;
  
  /* type '::ShaderStageMask' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderStageMask_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unknown",SWIG_From_int(static_cast< int >(ShaderStageMask::Unknown)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Vertex",SWIG_From_int(static_cast< int >(ShaderStageMask::Vertex)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Hull",SWIG_From_int(static_cast< int >(ShaderStageMask::Hull)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Tess_Control",SWIG_From_int(static_cast< int >(ShaderStageMask::Tess_Control)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Domain",SWIG_From_int(static_cast< int >(ShaderStageMask::Domain)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Tess_Eval",SWIG_From_int(static_cast< int >(ShaderStageMask::Tess_Eval)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Geometry",SWIG_From_int(static_cast< int >(ShaderStageMask::Geometry)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Pixel",SWIG_From_int(static_cast< int >(ShaderStageMask::Pixel)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Fragment",SWIG_From_int(static_cast< int >(ShaderStageMask::Fragment)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Compute",SWIG_From_int(static_cast< int >(ShaderStageMask::Compute)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Task",SWIG_From_int(static_cast< int >(ShaderStageMask::Task)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Amplification",SWIG_From_int(static_cast< int >(ShaderStageMask::Amplification)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Mesh",SWIG_From_int(static_cast< int >(ShaderStageMask::Mesh)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RayGen",SWIG_From_int(static_cast< int >(ShaderStageMask::RayGen)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Intersection",SWIG_From_int(static_cast< int >(ShaderStageMask::Intersection)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AnyHit",SWIG_From_int(static_cast< int >(ShaderStageMask::AnyHit)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ClosestHit",SWIG_From_int(static_cast< int >(ShaderStageMask::ClosestHit)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Miss",SWIG_From_int(static_cast< int >(ShaderStageMask::Miss)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Callable",SWIG_From_int(static_cast< int >(ShaderStageMask::Callable)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "All",SWIG_From_int(static_cast< int >(ShaderStageMask::All)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    if(Flag_class) constructor = Flag_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ShaderStageMask", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ShaderStageMask", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderStageMask'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ShaderStageMask", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderStageMask");
  d = md;
  
  /* type '::ShaderEvents' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderEvents_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoEvent",SWIG_From_int(static_cast< int >(ShaderEvents::NoEvent)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SampleLoadGather",SWIG_From_int(static_cast< int >(ShaderEvents::SampleLoadGather)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GeneratedNanOrInf",SWIG_From_int(static_cast< int >(ShaderEvents::GeneratedNanOrInf)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DebugBreak",SWIG_From_int(static_cast< int >(ShaderEvents::DebugBreak)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    if(Flag_class) constructor = Flag_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ShaderEvents", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ShaderEvents", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderEvents'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ShaderEvents", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderEvents");
  d = md;
  
  /* type '::ShaderVariableFlags' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderVariableFlags_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoFlags",SWIG_From_int(static_cast< int >(ShaderVariableFlags::NoFlags)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RowMajorMatrix",SWIG_From_int(static_cast< int >(ShaderVariableFlags::RowMajorMatrix)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "HexDisplay",SWIG_From_int(static_cast< int >(ShaderVariableFlags::HexDisplay)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BinaryDisplay",SWIG_From_int(static_cast< int >(ShaderVariableFlags::BinaryDisplay)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RGBDisplay",SWIG_From_int(static_cast< int >(ShaderVariableFlags::RGBDisplay)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "R11G11B10",SWIG_From_int(static_cast< int >(ShaderVariableFlags::R11G11B10)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "R10G10B10A2",SWIG_From_int(static_cast< int >(ShaderVariableFlags::R10G10B10A2)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "UNorm",SWIG_From_int(static_cast< int >(ShaderVariableFlags::UNorm)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SNorm",SWIG_From_int(static_cast< int >(ShaderVariableFlags::SNorm)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Truncated",SWIG_From_int(static_cast< int >(ShaderVariableFlags::Truncated)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SignedEnum",SWIG_From_int(static_cast< int >(ShaderVariableFlags::SignedEnum)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SingleElementArray",SWIG_From_int(static_cast< int >(ShaderVariableFlags::SingleElementArray)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    if(Flag_class) constructor = Flag_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ShaderVariableFlags", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ShaderVariableFlags", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderVariableFlags'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ShaderVariableFlags", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderVariableFlags");
  d = md;
  
  /* type '::ActionFlags' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ActionFlags_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoFlags",SWIG_From_int(static_cast< int >(ActionFlags::NoFlags)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Clear",SWIG_From_int(static_cast< int >(ActionFlags::Clear)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Drawcall",SWIG_From_int(static_cast< int >(ActionFlags::Drawcall)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Dispatch",SWIG_From_int(static_cast< int >(ActionFlags::Dispatch)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MeshDispatch",SWIG_From_int(static_cast< int >(ActionFlags::MeshDispatch)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CmdList",SWIG_From_int(static_cast< int >(ActionFlags::CmdList)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "SetMarker",SWIG_From_int(static_cast< int >(ActionFlags::SetMarker)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PushMarker",SWIG_From_int(static_cast< int >(ActionFlags::PushMarker)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PopMarker",SWIG_From_int(static_cast< int >(ActionFlags::PopMarker)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Present",SWIG_From_int(static_cast< int >(ActionFlags::Present)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "MultiAction",SWIG_From_int(static_cast< int >(ActionFlags::MultiAction)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Copy",SWIG_From_int(static_cast< int >(ActionFlags::Copy)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Resolve",SWIG_From_int(static_cast< int >(ActionFlags::Resolve)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GenMips",SWIG_From_int(static_cast< int >(ActionFlags::GenMips)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "PassBoundary",SWIG_From_int(static_cast< int >(ActionFlags::PassBoundary)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "DispatchRay",SWIG_From_int(static_cast< int >(ActionFlags::DispatchRay)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BuildAccStruct",SWIG_From_int(static_cast< int >(ActionFlags::BuildAccStruct)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Indexed",SWIG_From_int(static_cast< int >(ActionFlags::Indexed)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Instanced",SWIG_From_int(static_cast< int >(ActionFlags::Instanced)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Auto",SWIG_From_int(static_cast< int >(ActionFlags::Auto)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Indirect",SWIG_From_int(static_cast< int >(ActionFlags::Indirect)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ClearColor",SWIG_From_int(static_cast< int >(ActionFlags::ClearColor)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ClearDepthStencil",SWIG_From_int(static_cast< int >(ActionFlags::ClearDepthStencil)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "BeginPass",SWIG_From_int(static_cast< int >(ActionFlags::BeginPass)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "EndPass",SWIG_From_int(static_cast< int >(ActionFlags::EndPass)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "CommandBufferBoundary",SWIG_From_int(static_cast< int >(ActionFlags::CommandBufferBoundary)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    if(Flag_class) constructor = Flag_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "ActionFlags", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "ActionFlags", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'ActionFlags'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "ActionFlags", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ActionFlags");
  d = md;
  
  /* type '::VulkanLayerFlags' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VulkanLayerFlags_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoFlags",SWIG_From_int(static_cast< int >(VulkanLayerFlags::NoFlags)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "OtherInstallsRegistered",SWIG_From_int(static_cast< int >(VulkanLayerFlags::OtherInstallsRegistered)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "ThisInstallRegistered",SWIG_From_int(static_cast< int >(VulkanLayerFlags::ThisInstallRegistered)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NeedElevation",SWIG_From_int(static_cast< int >(VulkanLayerFlags::NeedElevation)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "UserRegisterable",SWIG_From_int(static_cast< int >(VulkanLayerFlags::UserRegisterable)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RegisterAll",SWIG_From_int(static_cast< int >(VulkanLayerFlags::RegisterAll)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "UpdateAllowed",SWIG_From_int(static_cast< int >(VulkanLayerFlags::UpdateAllowed)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unfixable",SWIG_From_int(static_cast< int >(VulkanLayerFlags::Unfixable)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Unsupported",SWIG_From_int(static_cast< int >(VulkanLayerFlags::Unsupported)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    if(Flag_class) constructor = Flag_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "VulkanLayerFlags", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "VulkanLayerFlags", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'VulkanLayerFlags'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "VulkanLayerFlags", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VulkanLayerFlags");
  d = md;
  
  /* type '::AndroidFlags' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__AndroidFlags_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoFlags",SWIG_From_int(static_cast< int >(AndroidFlags::NoFlags)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "Debuggable",SWIG_From_int(static_cast< int >(AndroidFlags::Debuggable)));
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "RootAccess",SWIG_From_int(static_cast< int >(AndroidFlags::RootAccess)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  if (Enum_class == NULL) SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  if (Enum_class == NULL) {
    PyDict_SetItemString(d, "this", this_descr);
    PyDict_SetItemString(d, "thisown", thisown_descr);
  }
  if (Enum_class) {
    PyObject *constructor = Enum_class;
    if(Flag_class) constructor = Flag_class;
    builtin_pytype->tp_base = (PyTypeObject *)PyObject_CallFunction(constructor, "sO", "AndroidFlags", d);
    PyObject_SetAttrString((PyObject *)builtin_pytype->tp_base, "__doc__", PyUnicode_FromString(builtin_pytype->tp_doc));
    PyModule_AddObject(m, "AndroidFlags", (PyObject *)builtin_pytype->tp_base);
    Py_DECREF(d);
    builtin_pytype->tp_dict = NULL;
  } else {
    if (PyType_Ready(builtin_pytype) < 0) {
      PyErr_SetString(PyExc_TypeError, "Could not create type 'AndroidFlags'.");
#if PY_VERSION_HEX >= 0x03000000
      return NULL;
#else
      return;
#endif
    }
    Py_INCREF(builtin_pytype);
    PyModule_AddObject(m, "AndroidFlags", (PyObject *)builtin_pytype);
  }
  SwigPyBuiltin_AddPublicSymbol(public_interface, "AndroidFlags");
  d = md;
  
  /* type '::PointerVal' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__PointerVal_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'PointerVal'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "PointerVal", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "PointerVal");
  d = md;
  
  /* type '::ShaderBindIndex' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderBindIndex_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderBindIndex'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderBindIndex", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderBindIndex");
  d = md;
  
  /* type '::ShaderDirectAccess' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderDirectAccess_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderDirectAccess'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderDirectAccess", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderDirectAccess");
  d = md;
  
  /* type '::ShaderValue' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderValue_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderValue'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderValue", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderValue");
  d = md;
  
  /* type '::ShaderVariable' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderVariable_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderVariable'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderVariable", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderVariable");
  d = md;
  
  /* type '::DebugVariableReference' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__DebugVariableReference_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'DebugVariableReference'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "DebugVariableReference", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "DebugVariableReference");
  d = md;
  
  /* type '::SourceVariableMapping' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SourceVariableMapping_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'SourceVariableMapping'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "SourceVariableMapping", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SourceVariableMapping");
  d = md;
  
  /* type '::LineColumnInfo' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__LineColumnInfo_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'LineColumnInfo'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "LineColumnInfo", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "LineColumnInfo");
  d = md;
  
  /* type '::InstructionSourceInfo' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__InstructionSourceInfo_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'InstructionSourceInfo'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "InstructionSourceInfo", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "InstructionSourceInfo");
  d = md;
  
  /* type '::ShaderVariableChange' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderVariableChange_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderVariableChange'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderVariableChange", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderVariableChange");
  d = md;
  
  /* type '::ShaderDebugState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderDebugState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderDebugState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderDebugState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderDebugState");
  d = md;
  
  /* type '::ShaderDebugger' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderDebugger_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderDebugger'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderDebugger", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderDebugger");
  d = md;
  
  /* type '::ShaderDebugTrace' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderDebugTrace_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderDebugTrace'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderDebugTrace", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderDebugTrace");
  d = md;
  
  /* type '::SigParameter' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__SigParameter_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "NoIndex",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(SigParameter::NoIndex)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'SigParameter'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "SigParameter", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "SigParameter");
  d = md;
  
  /* type '::ShaderConstantType' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderConstantType_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderConstantType'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderConstantType", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderConstantType");
  d = md;
  
  /* type '::ShaderConstant' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderConstant_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderConstant'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderConstant", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderConstant");
  d = md;
  
  /* type '::ConstantBlock' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ConstantBlock_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ConstantBlock'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ConstantBlock", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ConstantBlock");
  d = md;
  
  /* type '::ShaderSampler' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderSampler_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderSampler'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderSampler", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderSampler");
  d = md;
  
  /* type '::ShaderResource' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderResource_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderResource'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderResource", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderResource");
  d = md;
  
  /* type '::ShaderEntryPoint' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderEntryPoint_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderEntryPoint'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderEntryPoint", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderEntryPoint");
  d = md;
  
  /* type '::ShaderCompileFlag' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderCompileFlag_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderCompileFlag'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderCompileFlag", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderCompileFlag");
  d = md;
  
  /* type '::ShaderCompileFlags' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderCompileFlags_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderCompileFlags'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderCompileFlags", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderCompileFlags");
  d = md;
  
  /* type '::ShaderSourcePrefix' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderSourcePrefix_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderSourcePrefix'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderSourcePrefix", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderSourcePrefix");
  d = md;
  
  /* type '::ShaderSourceFile' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderSourceFile_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderSourceFile'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderSourceFile", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderSourceFile");
  d = md;
  
  /* type '::ShaderDebugInfo' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderDebugInfo_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderDebugInfo'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderDebugInfo", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderDebugInfo");
  d = md;
  
  /* type '::ShaderReflection' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__ShaderReflection_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'ShaderReflection'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "ShaderReflection", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "ShaderReflection");
  d = md;
  
  /* type 'VKPipe::DynamicOffset' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__DynamicOffset_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKDynamicOffset'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKDynamicOffset", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKDynamicOffset");
  d = md;
  
  /* type 'VKPipe::DescriptorSet' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__DescriptorSet_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKDescriptorSet'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKDescriptorSet", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKDescriptorSet");
  d = md;
  
  /* type 'VKPipe::DescriptorBuffer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__DescriptorBuffer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKDescriptorBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKDescriptorBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKDescriptorBuffer");
  d = md;
  
  /* type 'VKPipe::Pipeline' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__Pipeline_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKPipeline'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKPipeline", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKPipeline");
  d = md;
  
  /* type 'VKPipe::IndexBuffer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__IndexBuffer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKIndexBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKIndexBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKIndexBuffer");
  d = md;
  
  /* type 'VKPipe::InputAssembly' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__InputAssembly_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKInputAssembly'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKInputAssembly", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKInputAssembly");
  d = md;
  
  /* type 'VKPipe::VertexAttribute' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__VertexAttribute_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKVertexAttribute'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKVertexAttribute", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKVertexAttribute");
  d = md;
  
  /* type 'VKPipe::VertexBinding' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__VertexBinding_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKVertexBinding'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKVertexBinding", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKVertexBinding");
  d = md;
  
  /* type 'VKPipe::VertexBuffer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__VertexBuffer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKVertexBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKVertexBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKVertexBuffer");
  d = md;
  
  /* type 'VKPipe::VertexInput' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__VertexInput_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKVertexInput'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKVertexInput", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKVertexInput");
  d = md;
  
  /* type 'VKPipe::Shader' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__Shader_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKShader'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKShader", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKShader");
  d = md;
  
  /* type 'VKPipe::Tessellation' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__Tessellation_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKTessellation'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKTessellation", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKTessellation");
  d = md;
  
  /* type 'VKPipe::XFBBuffer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__XFBBuffer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKXFBBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKXFBBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKXFBBuffer");
  d = md;
  
  /* type 'VKPipe::TransformFeedback' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__TransformFeedback_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKTransformFeedback'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKTransformFeedback", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKTransformFeedback");
  d = md;
  
  /* type 'VKPipe::RenderArea' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__RenderArea_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKRenderArea'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKRenderArea", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKRenderArea");
  d = md;
  
  /* type 'VKPipe::ViewportScissor' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__ViewportScissor_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKViewportScissor'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKViewportScissor", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKViewportScissor");
  d = md;
  
  /* type 'VKPipe::ViewState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__ViewState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKViewState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKViewState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKViewState");
  d = md;
  
  /* type 'VKPipe::Rasterizer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__Rasterizer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKRasterizer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKRasterizer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKRasterizer");
  d = md;
  
  /* type 'VKPipe::SampleLocations' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__SampleLocations_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKSampleLocations'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKSampleLocations", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKSampleLocations");
  d = md;
  
  /* type 'VKPipe::MultiSample' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__MultiSample_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKMultiSample'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKMultiSample", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKMultiSample");
  d = md;
  
  /* type 'VKPipe::ColorBlendState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__ColorBlendState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKColorBlendState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKColorBlendState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKColorBlendState");
  d = md;
  
  /* type 'VKPipe::DepthStencil' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__DepthStencil_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKDepthStencil'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKDepthStencil", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKDepthStencil");
  d = md;
  
  /* type 'VKPipe::RenderPass' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__RenderPass_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "AttachmentUnused",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VKPipe::RenderPass::AttachmentUnused)));
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKRenderPass'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKRenderPass", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKRenderPass");
  d = md;
  
  /* type 'VKPipe::Framebuffer' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__Framebuffer_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKFramebuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKFramebuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKFramebuffer");
  d = md;
  
  /* type 'VKPipe::CurrentPass' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__CurrentPass_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKCurrentPass'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKCurrentPass", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKCurrentPass");
  d = md;
  
  /* type 'VKPipe::ImageLayout' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__ImageLayout_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKImageLayout'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKImageLayout", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKImageLayout");
  d = md;
  
  /* type 'VKPipe::ImageData' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__ImageData_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKImageData'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKImageData", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKImageData");
  d = md;
  
  /* type 'VKPipe::ConditionalRendering' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__ConditionalRendering_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKConditionalRendering'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKConditionalRendering", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKConditionalRendering");
  d = md;
  
  /* type 'VKPipe::State' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__VKPipe__State_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'VKState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "VKState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "VKState");
  d = md;
  
  /* type '::PipeState' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__PipeState_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'PipeState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "PipeState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "PipeState");
  d = md;
  
  /* type '::rdcarray< int >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_int_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_int'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_int", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_int");
  d = md;
  
  /* type '::rdcarray< float >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_float_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_float'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_float", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_float");
  d = md;
  
  /* type '::rdcarray< uint32_t >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_uint32_t_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_uint32_t'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_uint32_t", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_uint32_t");
  d = md;
  
  /* type '::rdcarray< uint64_t >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_uint64_t_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_uint64_t'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_uint64_t", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_uint64_t");
  d = md;
  
  /* type '::rdcarray< rdcstr >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_rdcstr_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_rdcstr'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_rdcstr", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_rdcstr");
  d = md;
  
  /* type '::rdcarray< WindowingSystem >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_WindowingSystem_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_WindowingSystem'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_WindowingSystem", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_WindowingSystem");
  d = md;
  
  /* type '::rdcarray< ActionDescription >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ActionDescription_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ActionDescription'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ActionDescription", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ActionDescription");
  d = md;
  
  /* type '::rdcarray< GPUCounter >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_GPUCounter_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_GPUCounter'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_GPUCounter", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_GPUCounter");
  d = md;
  
  /* type '::rdcarray< CounterResult >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_CounterResult_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_CounterResult'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_CounterResult", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_CounterResult");
  d = md;
  
  /* type '::rdcarray< APIEvent >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_APIEvent_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_APIEvent'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_APIEvent", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_APIEvent");
  d = md;
  
  /* type '::rdcarray< DescriptorStoreDescription >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_DescriptorStoreDescription_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_DescriptorStoreDescription'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_DescriptorStoreDescription", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_DescriptorStoreDescription");
  d = md;
  
  /* type '::rdcarray< BufferDescription >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_BufferDescription_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_BufferDescription'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_BufferDescription", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_BufferDescription");
  d = md;
  
  /* type '::rdcarray< CaptureFileFormat >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_CaptureFileFormat_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_CaptureFileFormat'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_CaptureFileFormat", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_CaptureFileFormat");
  d = md;
  
  /* type '::rdcarray< ConstantBlock >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ConstantBlock_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ConstantBlock'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ConstantBlock", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ConstantBlock");
  d = md;
  
  /* type '::rdcarray< DebugMessage >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_DebugMessage_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_DebugMessage'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_DebugMessage", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_DebugMessage");
  d = md;
  
  /* type '::rdcarray< EnvironmentModification >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_EnvironmentModification_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_EnvironmentModification'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_EnvironmentModification", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_EnvironmentModification");
  d = md;
  
  /* type '::rdcarray< EventUsage >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_EventUsage_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_EventUsage'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_EventUsage", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_EventUsage");
  d = md;
  
  /* type '::rdcarray< PathEntry >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_PathEntry_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_PathEntry'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_PathEntry", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_PathEntry");
  d = md;
  
  /* type '::rdcarray< PixelModification >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_PixelModification_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_PixelModification'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_PixelModification", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_PixelModification");
  d = md;
  
  /* type '::rdcarray< TaskGroupSize >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_TaskGroupSize_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_TaskGroupSize'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_TaskGroupSize", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_TaskGroupSize");
  d = md;
  
  /* type '::rdcarray< MeshletSize >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_MeshletSize_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_MeshletSize'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_MeshletSize", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_MeshletSize");
  d = md;
  
  /* type '::rdcarray< ResourceDescription >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ResourceDescription_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ResourceDescription'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ResourceDescription", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ResourceDescription");
  d = md;
  
  /* type '::rdcarray< ResourceId >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ResourceId_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ResourceId'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ResourceId", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ResourceId");
  d = md;
  
  /* type '::rdcarray< LineColumnInfo >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_LineColumnInfo_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_LineColumnInfo'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_LineColumnInfo", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_LineColumnInfo");
  d = md;
  
  /* type '::rdcarray< InstructionSourceInfo >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_InstructionSourceInfo_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_InstructionSourceInfo'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_InstructionSourceInfo", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_InstructionSourceInfo");
  d = md;
  
  /* type '::rdcarray< ShaderCompileFlag >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderCompileFlag_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderCompileFlag'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderCompileFlag", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderCompileFlag");
  d = md;
  
  /* type '::rdcarray< ShaderConstant >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderConstant_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderConstant'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderConstant", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderConstant");
  d = md;
  
  /* type '::rdcarray< ShaderDebugState >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderDebugState_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderDebugState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderDebugState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderDebugState");
  d = md;
  
  /* type '::rdcarray< ShaderMessage >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderMessage_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderMessage'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderMessage", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderMessage");
  d = md;
  
  /* type '::rdcarray< ShaderResource >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderResource_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderResource'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderResource", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderResource");
  d = md;
  
  /* type '::rdcarray< ShaderSampler >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderSampler_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderSampler'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderSampler", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderSampler");
  d = md;
  
  /* type '::rdcarray< ShaderSourceFile >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderSourceFile_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderSourceFile'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderSourceFile", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderSourceFile");
  d = md;
  
  /* type '::rdcarray< ShaderSourcePrefix >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderSourcePrefix_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderSourcePrefix'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderSourcePrefix", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderSourcePrefix");
  d = md;
  
  /* type '::rdcarray< ShaderVariable >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderVariable_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderVariable'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderVariable", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderVariable");
  d = md;
  
  /* type '::rdcarray< ShaderEncoding >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderEncoding_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderEncoding'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderEncoding", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderEncoding");
  d = md;
  
  /* type '::rdcarray< ShaderVariableChange >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderVariableChange_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderVariableChange'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderVariableChange", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderVariableChange");
  d = md;
  
  /* type '::rdcarray< DebugVariableReference >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_DebugVariableReference_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_DebugVariableReference'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_DebugVariableReference", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_DebugVariableReference");
  d = md;
  
  /* type '::rdcarray< SourceVariableMapping >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_SourceVariableMapping_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_SourceVariableMapping'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_SourceVariableMapping", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_SourceVariableMapping");
  d = md;
  
  /* type '::rdcarray< SigParameter >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_SigParameter_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_SigParameter'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_SigParameter", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_SigParameter");
  d = md;
  
  /* type '::rdcarray< TextureDescription >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_TextureDescription_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_TextureDescription'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_TextureDescription", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_TextureDescription");
  d = md;
  
  /* type '::rdcarray< ShaderEntryPoint >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderEntryPoint_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderEntryPoint'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderEntryPoint", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderEntryPoint");
  d = md;
  
  /* type '::rdcarray< Viewport >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_Viewport_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_Viewport'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_Viewport", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_Viewport");
  d = md;
  
  /* type '::rdcarray< Scissor >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_Scissor_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_Scissor'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_Scissor", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_Scissor");
  d = md;
  
  /* type '::rdcarray< ColorBlend >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ColorBlend_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ColorBlend'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ColorBlend", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ColorBlend");
  d = md;
  
  /* type '::rdcarray< BoundVBuffer >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_BoundVBuffer_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_BoundVBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_BoundVBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_BoundVBuffer");
  d = md;
  
  /* type '::rdcarray< Offset >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_Offset_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_Offset'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_Offset", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_Offset");
  d = md;
  
  /* type '::rdcarray< VertexInputAttribute >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VertexInputAttribute_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_VertexInputAttribute'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_VertexInputAttribute", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_VertexInputAttribute");
  d = md;
  
  /* type '::rdcarray< FloatVector >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_FloatVector_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_FloatVector'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_FloatVector", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_FloatVector");
  d = md;
  
  /* type '::rdcarray< GraphicsAPI >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_GraphicsAPI_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_GraphicsAPI'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_GraphicsAPI", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_GraphicsAPI");
  d = md;
  
  /* type '::rdcarray< GPUDevice >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_GPUDevice_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_GPUDevice'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_GPUDevice", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_GPUDevice");
  d = md;
  
  /* type '::rdcarray< ShaderConstantType >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderConstantType_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderConstantType'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderConstantType", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderConstantType");
  d = md;
  
  /* type '::rdcarray< ShaderChangeStats >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ShaderChangeStats_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ShaderChangeStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ShaderChangeStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ShaderChangeStats");
  d = md;
  
  /* type '::rdcarray< ResourceBindStats >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ResourceBindStats_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ResourceBindStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ResourceBindStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ResourceBindStats");
  d = md;
  
  /* type '::rdcarray< SamplerBindStats >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_SamplerBindStats_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_SamplerBindStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_SamplerBindStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_SamplerBindStats");
  d = md;
  
  /* type '::rdcarray< ConstantBindStats >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_ConstantBindStats_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_ConstantBindStats'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_ConstantBindStats", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_ConstantBindStats");
  d = md;
  
  /* type '::rdcarray< DescriptorRange >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_DescriptorRange_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_DescriptorRange'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_DescriptorRange", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_DescriptorRange");
  d = md;
  
  /* type '::rdcarray< Descriptor >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_Descriptor_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_Descriptor'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_Descriptor", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_Descriptor");
  d = md;
  
  /* type '::rdcarray< SamplerDescriptor >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_SamplerDescriptor_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_SamplerDescriptor'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_SamplerDescriptor", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_SamplerDescriptor");
  d = md;
  
  /* type '::rdcarray< DescriptorAccess >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_DescriptorAccess_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_DescriptorAccess'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_DescriptorAccess", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_DescriptorAccess");
  d = md;
  
  /* type '::rdcarray< DescriptorLogicalLocation >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_DescriptorLogicalLocation_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_DescriptorLogicalLocation'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_DescriptorLogicalLocation", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_DescriptorLogicalLocation");
  d = md;
  
  /* type '::rdcarray< UsedDescriptor >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_UsedDescriptor_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_UsedDescriptor'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_UsedDescriptor", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_UsedDescriptor");
  d = md;
  
  /* type 'rdcarray< VKPipe::DynamicOffset >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__DynamicOffset_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_VKPipe_DynamicOffset'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_VKPipe_DynamicOffset", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_VKPipe_DynamicOffset");
  d = md;
  
  /* type 'rdcarray< VKPipe::DescriptorSet >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorSet_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_VKPipe_DescriptorSet'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_VKPipe_DescriptorSet", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_VKPipe_DescriptorSet");
  d = md;
  
  /* type 'rdcarray< VKPipe::DescriptorBuffer >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__DescriptorBuffer_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_VKPipe_DescriptorBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_VKPipe_DescriptorBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_VKPipe_DescriptorBuffer");
  d = md;
  
  /* type 'rdcarray< VKPipe::ImageData >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__ImageData_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_VKPipe_ImageData'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_VKPipe_ImageData", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_VKPipe_ImageData");
  d = md;
  
  /* type 'rdcarray< VKPipe::ImageLayout >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__ImageLayout_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_VKPipe_ImageLayout'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_VKPipe_ImageLayout", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_VKPipe_ImageLayout");
  d = md;
  
  /* type 'rdcarray< VKPipe::RenderArea >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__RenderArea_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_VKPipe_RenderArea'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_VKPipe_RenderArea", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_VKPipe_RenderArea");
  d = md;
  
  /* type 'rdcarray< VKPipe::XFBBuffer >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__XFBBuffer_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_VKPipe_XFBBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_VKPipe_XFBBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_VKPipe_XFBBuffer");
  d = md;
  
  /* type 'rdcarray< VKPipe::VertexBuffer >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__VertexBuffer_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_VKPipe_VertexBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_VKPipe_VertexBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_VKPipe_VertexBuffer");
  d = md;
  
  /* type 'rdcarray< VKPipe::VertexAttribute >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__VertexAttribute_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_VKPipe_VertexAttribute'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_VKPipe_VertexAttribute", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_VKPipe_VertexAttribute");
  d = md;
  
  /* type 'rdcarray< VKPipe::VertexBinding >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__VertexBinding_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_VKPipe_VertexBinding'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_VKPipe_VertexBinding", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_VKPipe_VertexBinding");
  d = md;
  
  /* type 'rdcarray< VKPipe::ViewportScissor >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_VKPipe__ViewportScissor_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_VKPipe_ViewportScissor'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_VKPipe_ViewportScissor", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_VKPipe_ViewportScissor");
  d = md;
  
  /* type 'rdcarray< D3D11Pipe::Layout >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D11Pipe__Layout_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_D3D11Pipe_Layout'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_D3D11Pipe_Layout", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_D3D11Pipe_Layout");
  d = md;
  
  /* type 'rdcarray< D3D11Pipe::StreamOutBind >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D11Pipe__StreamOutBind_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_D3D11Pipe_StreamOutBind'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_D3D11Pipe_StreamOutBind", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_D3D11Pipe_StreamOutBind");
  d = md;
  
  /* type 'rdcarray< D3D11Pipe::VertexBuffer >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D11Pipe__VertexBuffer_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_D3D11Pipe_VertexBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_D3D11Pipe_VertexBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_D3D11Pipe_VertexBuffer");
  d = md;
  
  /* type 'rdcarray< D3D12Pipe::Layout >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__Layout_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_D3D12Pipe_Layout'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_D3D12Pipe_Layout", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_D3D12Pipe_Layout");
  d = md;
  
  /* type 'rdcarray< D3D12Pipe::ResourceData >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceData_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_D3D12Pipe_ResourceData'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_D3D12Pipe_ResourceData", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_D3D12Pipe_ResourceData");
  d = md;
  
  /* type 'rdcarray< D3D12Pipe::ResourceState >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__ResourceState_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_D3D12Pipe_ResourceState'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_D3D12Pipe_ResourceState", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_D3D12Pipe_ResourceState");
  d = md;
  
  /* type 'rdcarray< D3D12Pipe::StreamOutBind >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__StreamOutBind_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_D3D12Pipe_StreamOutBind'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_D3D12Pipe_StreamOutBind", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_D3D12Pipe_StreamOutBind");
  d = md;
  
  /* type 'rdcarray< D3D12Pipe::VertexBuffer >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__VertexBuffer_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_D3D12Pipe_VertexBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_D3D12Pipe_VertexBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_D3D12Pipe_VertexBuffer");
  d = md;
  
  /* type 'rdcarray< D3D12Pipe::RootTableRange >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootTableRange_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_D3D12Pipe_RootTableRange'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_D3D12Pipe_RootTableRange", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_D3D12Pipe_RootTableRange");
  d = md;
  
  /* type 'rdcarray< D3D12Pipe::RootParam >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__RootParam_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_D3D12Pipe_RootParam'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_D3D12Pipe_RootParam", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_D3D12Pipe_RootParam");
  d = md;
  
  /* type 'rdcarray< D3D12Pipe::StaticSampler >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_D3D12Pipe__StaticSampler_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_D3D12Pipe_StaticSampler'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_D3D12Pipe_StaticSampler", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_D3D12Pipe_StaticSampler");
  d = md;
  
  /* type 'rdcarray< GLPipe::VertexBuffer >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_GLPipe__VertexBuffer_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_GLPipe_VertexBuffer'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_GLPipe_VertexBuffer", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_GLPipe_VertexBuffer");
  d = md;
  
  /* type 'rdcarray< GLPipe::VertexAttribute >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_GLPipe__VertexAttribute_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_GLPipe_VertexAttribute'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_GLPipe_VertexAttribute", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_GLPipe_VertexAttribute");
  d = md;
  
  /* type 'rdcarray< GLPipe::TextureCompleteness >' */
  builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__rdcarrayT_GLPipe__TextureCompleteness_t_type;
  builtin_pytype->tp_dict = d = PyDict_New();
  SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
  builtin_pytype->tp_new = PyType_GenericNew;
  builtin_base_count = 0;
  builtin_bases[builtin_base_count] = NULL;
  SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
  PyDict_SetItemString(d, "this", this_descr);
  PyDict_SetItemString(d, "thisown", thisown_descr);
  if (PyType_Ready(builtin_pytype) < 0) {
    PyErr_SetString(PyExc_TypeError, "Could not create type 'rdcarray_of_GLPipe_TextureCompleteness'.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  Py_INCREF(builtin_pytype);
  PyModule_AddObject(m, "rdcarray_of_GLPipe_TextureCompleteness", (PyObject *)builtin_pytype);
  SwigPyBuiltin_AddPublicSymbol(public_interface, "rdcarray_of_GLPipe_TextureCompleteness");
  d = md;
  
  interfaceCheckTypes = swig_type_initial;
  interfaceCheckNumTypes = sizeof(swig_type_initial)/sizeof(swig_type_initial[0]);
  
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

